
/* Copyright (c) 2015-2023 Valve Corporation
 * Copyright (c) 2015-2023 LunarG, Inc.
 * Copyright (c) 2015-2016, 2019 Google 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 <lenny@lunarg.com>
 * Author: Shannon McPherson <shannon@lunarg.com>
 * Author: Charles Giessen <charles@lunarg.com>
 */

/*
 * This file is generated from the Khronos Vulkan XML API Registry.
 */


#include "api_dump_text.h"

#include "api_dump_video_text.h"

//=========================== Type Implementations ==========================//

void dump_text_uint64_t(uint64_t object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_size_t(size_t object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_char(char object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_float(float object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_int64_t(int64_t object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_double(double object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}

//========================= Basetype Implementations ========================//

void dump_text_VkBool32(VkBool32 object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDeviceAddress(VkDeviceAddress object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDeviceSize(VkDeviceSize object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkFlags(VkFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkSampleMask(VkSampleMask object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkFlags64(VkFlags64 object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_MTLDevice_id(MTLDevice_id object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_MTLCommandQueue_id(MTLCommandQueue_id object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_MTLBuffer_id(MTLBuffer_id object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_MTLTexture_id(MTLTexture_id object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_IOSurfaceRef(IOSurfaceRef object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_MTLSharedEvent_id(MTLSharedEvent_id object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkRemoteAddressNV(VkRemoteAddressNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}


#if defined(VK_USE_PLATFORM_ANDROID_KHR)
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_ANativeWindow(const ANativeWindow* object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_AHardwareBuffer(const AHardwareBuffer* object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif
#endif // VK_USE_PLATFORM_ANDROID_KHR


#if defined(VK_USE_PLATFORM_METAL_EXT)
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_CAMetalLayer(CAMetalLayer object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif
#endif // VK_USE_PLATFORM_METAL_EXT

//======================= System Type Implementations =======================//

#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_DWORD(const DWORD object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_Display(const Display* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_GgpFrameToken(const GgpFrameToken object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_GGP
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_GgpStreamDescriptor(const GgpStreamDescriptor object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_GGP
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_HANDLE(const HANDLE object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_HINSTANCE(const HINSTANCE object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_HMONITOR(const HMONITOR object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_HWND(const HWND object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_IDirectFB(const IDirectFB object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_IDirectFBSurface(const IDirectFBSurface object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_LPCWSTR(const LPCWSTR object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_SECURITY_ATTRIBUTES(const SECURITY_ATTRIBUTES* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_VisualID(const VisualID object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_Window(const Window object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text__screen_buffer(const _screen_buffer* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text__screen_context(const _screen_context* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text__screen_window(const _screen_window* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_wl_display(const wl_display* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_wl_surface(const wl_surface* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_xcb_connection_t(const xcb_connection_t* object, const ApiDumpSettings& settings, int indents)
{
    if (object == NULL) {
        settings.stream() << "NULL";
        return;
    }
    OutputAddress(settings, object);
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_xcb_visualid_t(const xcb_visualid_t object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_xcb_window_t(const xcb_window_t object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_zx_handle_t(const zx_handle_t object, const ApiDumpSettings& settings, int indents)
{
    if (settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
#endif // VK_USE_PLATFORM_FUCHSIA

//========================== Handle Implementations =========================//

void dump_text_VkBuffer(const VkBuffer object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkImage(const VkImage object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkInstance(const VkInstance object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPhysicalDevice(const VkPhysicalDevice object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDevice(const VkDevice object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkQueue(const VkQueue object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkSemaphore(const VkSemaphore object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkCommandBuffer(const VkCommandBuffer object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkFence(const VkFence object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDeviceMemory(const VkDeviceMemory object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkEvent(const VkEvent object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkQueryPool(const VkQueryPool object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkBufferView(const VkBufferView object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkImageView(const VkImageView object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkShaderModule(const VkShaderModule object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPipelineCache(const VkPipelineCache object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPipelineLayout(const VkPipelineLayout object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPipeline(const VkPipeline object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkRenderPass(const VkRenderPass object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDescriptorSetLayout(const VkDescriptorSetLayout object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkSampler(const VkSampler object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDescriptorSet(const VkDescriptorSet object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDescriptorPool(const VkDescriptorPool object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkFramebuffer(const VkFramebuffer object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkCommandPool(const VkCommandPool object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDescriptorUpdateTemplate(const VkDescriptorUpdateTemplate object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPrivateDataSlot(const VkPrivateDataSlot object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkSurfaceKHR(const VkSurfaceKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkSwapchainKHR(const VkSwapchainKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDisplayKHR(const VkDisplayKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDisplayModeKHR(const VkDisplayModeKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDebugReportCallbackEXT(const VkDebugReportCallbackEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkVideoSessionKHR(const VkVideoSessionKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkVideoSessionParametersKHR(const VkVideoSessionParametersKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkCuModuleNVX(const VkCuModuleNVX object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkCuFunctionNVX(const VkCuFunctionNVX object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkAccelerationStructureKHR(const VkAccelerationStructureKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkDeferredOperationKHR(const VkDeferredOperationKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkValidationCacheEXT(const VkValidationCacheEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkAccelerationStructureNV(const VkAccelerationStructureNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPerformanceConfigurationINTEL(const VkPerformanceConfigurationINTEL object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkCudaModuleNV(const VkCudaModuleNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkCudaFunctionNV(const VkCudaFunctionNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionFUCHSIA(const VkBufferCollectionFUCHSIA object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
void dump_text_VkMicromapEXT(const VkMicromapEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkOpticalFlowSessionNV(const VkOpticalFlowSessionNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkShaderEXT(const VkShaderEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkPipelineBinaryKHR(const VkPipelineBinaryKHR object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkExternalComputeQueueNV(const VkExternalComputeQueueNV object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkIndirectExecutionSetEXT(const VkIndirectExecutionSetEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}
void dump_text_VkIndirectCommandsLayoutEXT(const VkIndirectCommandsLayoutEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress()) {
        settings.stream() << object;

        std::unordered_map<uint64_t, std::string>::const_iterator it = ApiDumpInstance::current().object_name_map.find((uint64_t) object);
        if (it != ApiDumpInstance::current().object_name_map.end()) {
            settings.stream() << " [" << it->second << "]";
        }
    } else {
        settings.stream() << "address";
    }
}

//=========================== Enum Implementations ==========================//

void dump_text_VkResult(VkResult object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SUCCESS (";
        break;
    case 1:
        settings.stream() << "VK_NOT_READY (";
        break;
    case 2:
        settings.stream() << "VK_TIMEOUT (";
        break;
    case 3:
        settings.stream() << "VK_EVENT_SET (";
        break;
    case 4:
        settings.stream() << "VK_EVENT_RESET (";
        break;
    case 5:
        settings.stream() << "VK_INCOMPLETE (";
        break;
    case -1:
        settings.stream() << "VK_ERROR_OUT_OF_HOST_MEMORY (";
        break;
    case -2:
        settings.stream() << "VK_ERROR_OUT_OF_DEVICE_MEMORY (";
        break;
    case -3:
        settings.stream() << "VK_ERROR_INITIALIZATION_FAILED (";
        break;
    case -4:
        settings.stream() << "VK_ERROR_DEVICE_LOST (";
        break;
    case -5:
        settings.stream() << "VK_ERROR_MEMORY_MAP_FAILED (";
        break;
    case -6:
        settings.stream() << "VK_ERROR_LAYER_NOT_PRESENT (";
        break;
    case -7:
        settings.stream() << "VK_ERROR_EXTENSION_NOT_PRESENT (";
        break;
    case -8:
        settings.stream() << "VK_ERROR_FEATURE_NOT_PRESENT (";
        break;
    case -9:
        settings.stream() << "VK_ERROR_INCOMPATIBLE_DRIVER (";
        break;
    case -10:
        settings.stream() << "VK_ERROR_TOO_MANY_OBJECTS (";
        break;
    case -11:
        settings.stream() << "VK_ERROR_FORMAT_NOT_SUPPORTED (";
        break;
    case -12:
        settings.stream() << "VK_ERROR_FRAGMENTED_POOL (";
        break;
    case -13:
        settings.stream() << "VK_ERROR_UNKNOWN (";
        break;
    case -1000069000:
        settings.stream() << "VK_ERROR_OUT_OF_POOL_MEMORY (";
        break;
    case -1000072003:
        settings.stream() << "VK_ERROR_INVALID_EXTERNAL_HANDLE (";
        break;
    case -1000161000:
        settings.stream() << "VK_ERROR_FRAGMENTATION (";
        break;
    case -1000257000:
        settings.stream() << "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS (";
        break;
    case 1000297000:
        settings.stream() << "VK_PIPELINE_COMPILE_REQUIRED (";
        break;
    case -1000174001:
        settings.stream() << "VK_ERROR_NOT_PERMITTED (";
        break;
    case -1000000000:
        settings.stream() << "VK_ERROR_SURFACE_LOST_KHR (";
        break;
    case -1000000001:
        settings.stream() << "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR (";
        break;
    case 1000001003:
        settings.stream() << "VK_SUBOPTIMAL_KHR (";
        break;
    case -1000001004:
        settings.stream() << "VK_ERROR_OUT_OF_DATE_KHR (";
        break;
    case -1000003001:
        settings.stream() << "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR (";
        break;
    case -1000011001:
        settings.stream() << "VK_ERROR_VALIDATION_FAILED_EXT (";
        break;
    case -1000012000:
        settings.stream() << "VK_ERROR_INVALID_SHADER_NV (";
        break;
    case -1000023000:
        settings.stream() << "VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR (";
        break;
    case -1000023001:
        settings.stream() << "VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR (";
        break;
    case -1000023002:
        settings.stream() << "VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR (";
        break;
    case -1000023003:
        settings.stream() << "VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR (";
        break;
    case -1000023004:
        settings.stream() << "VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR (";
        break;
    case -1000023005:
        settings.stream() << "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR (";
        break;
    case -1000158000:
        settings.stream() << "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT (";
        break;
    case -1000255000:
        settings.stream() << "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT (";
        break;
    case 1000268000:
        settings.stream() << "VK_THREAD_IDLE_KHR (";
        break;
    case 1000268001:
        settings.stream() << "VK_THREAD_DONE_KHR (";
        break;
    case 1000268002:
        settings.stream() << "VK_OPERATION_DEFERRED_KHR (";
        break;
    case 1000268003:
        settings.stream() << "VK_OPERATION_NOT_DEFERRED_KHR (";
        break;
    case -1000299000:
        settings.stream() << "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR (";
        break;
    case -1000338000:
        settings.stream() << "VK_ERROR_COMPRESSION_EXHAUSTED_EXT (";
        break;
    case 1000482000:
        settings.stream() << "VK_INCOMPATIBLE_SHADER_BINARY_EXT (";
        break;
    case 1000483000:
        settings.stream() << "VK_PIPELINE_BINARY_MISSING_KHR (";
        break;
    case -1000483000:
        settings.stream() << "VK_ERROR_NOT_ENOUGH_SPACE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkStructureType(VkStructureType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_STRUCTURE_TYPE_APPLICATION_INFO (";
        break;
    case 1:
        settings.stream() << "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO (";
        break;
    case 2:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO (";
        break;
    case 3:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO (";
        break;
    case 4:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBMIT_INFO (";
        break;
    case 5:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO (";
        break;
    case 6:
        settings.stream() << "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE (";
        break;
    case 7:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO (";
        break;
    case 8:
        settings.stream() << "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO (";
        break;
    case 9:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO (";
        break;
    case 10:
        settings.stream() << "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO (";
        break;
    case 11:
        settings.stream() << "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO (";
        break;
    case 12:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO (";
        break;
    case 13:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO (";
        break;
    case 14:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO (";
        break;
    case 15:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO (";
        break;
    case 16:
        settings.stream() << "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO (";
        break;
    case 17:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO (";
        break;
    case 18:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO (";
        break;
    case 19:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO (";
        break;
    case 20:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO (";
        break;
    case 21:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO (";
        break;
    case 22:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO (";
        break;
    case 23:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO (";
        break;
    case 24:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO (";
        break;
    case 25:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO (";
        break;
    case 26:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO (";
        break;
    case 27:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO (";
        break;
    case 28:
        settings.stream() << "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO (";
        break;
    case 29:
        settings.stream() << "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO (";
        break;
    case 30:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO (";
        break;
    case 31:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO (";
        break;
    case 32:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO (";
        break;
    case 33:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO (";
        break;
    case 34:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO (";
        break;
    case 35:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET (";
        break;
    case 36:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET (";
        break;
    case 37:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO (";
        break;
    case 38:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO (";
        break;
    case 39:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO (";
        break;
    case 40:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO (";
        break;
    case 41:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO (";
        break;
    case 42:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO (";
        break;
    case 43:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO (";
        break;
    case 44:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER (";
        break;
    case 45:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER (";
        break;
    case 46:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_BARRIER (";
        break;
    case 47:
        settings.stream() << "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO (";
        break;
    case 48:
        settings.stream() << "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO (";
        break;
    case 1000094000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES (";
        break;
    case 1000157000:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO (";
        break;
    case 1000157001:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO (";
        break;
    case 1000083000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES (";
        break;
    case 1000127000:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS (";
        break;
    case 1000127001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO (";
        break;
    case 1000060000:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO (";
        break;
    case 1000060003:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO (";
        break;
    case 1000060004:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO (";
        break;
    case 1000060005:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO (";
        break;
    case 1000060006:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO (";
        break;
    case 1000060013:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO (";
        break;
    case 1000060014:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO (";
        break;
    case 1000070000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES (";
        break;
    case 1000070001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO (";
        break;
    case 1000146000:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 (";
        break;
    case 1000146001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 (";
        break;
    case 1000146002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 (";
        break;
    case 1000146003:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 (";
        break;
    case 1000146004:
        settings.stream() << "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 (";
        break;
    case 1000059000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 (";
        break;
    case 1000059001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 (";
        break;
    case 1000059002:
        settings.stream() << "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 (";
        break;
    case 1000059003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 (";
        break;
    case 1000059004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 (";
        break;
    case 1000059005:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 (";
        break;
    case 1000059006:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 (";
        break;
    case 1000059007:
        settings.stream() << "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 (";
        break;
    case 1000059008:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 (";
        break;
    case 1000117000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES (";
        break;
    case 1000117001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO (";
        break;
    case 1000117002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO (";
        break;
    case 1000117003:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO (";
        break;
    case 1000053000:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO (";
        break;
    case 1000053001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES (";
        break;
    case 1000053002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES (";
        break;
    case 1000120000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES (";
        break;
    case 1000145000:
        settings.stream() << "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO (";
        break;
    case 1000145001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES (";
        break;
    case 1000145002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES (";
        break;
    case 1000145003:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 (";
        break;
    case 1000156000:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO (";
        break;
    case 1000156001:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO (";
        break;
    case 1000156002:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO (";
        break;
    case 1000156003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO (";
        break;
    case 1000156004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES (";
        break;
    case 1000156005:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES (";
        break;
    case 1000085000:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO (";
        break;
    case 1000071000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO (";
        break;
    case 1000071001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES (";
        break;
    case 1000071002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO (";
        break;
    case 1000071003:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES (";
        break;
    case 1000071004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES (";
        break;
    case 1000072000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO (";
        break;
    case 1000072001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO (";
        break;
    case 1000072002:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO (";
        break;
    case 1000112000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO (";
        break;
    case 1000112001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES (";
        break;
    case 1000113000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO (";
        break;
    case 1000077000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO (";
        break;
    case 1000076000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO (";
        break;
    case 1000076001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES (";
        break;
    case 1000168000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES (";
        break;
    case 1000168001:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT (";
        break;
    case 1000063000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES (";
        break;
    case 49:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES (";
        break;
    case 50:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES (";
        break;
    case 51:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES (";
        break;
    case 52:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES (";
        break;
    case 1000147000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO (";
        break;
    case 1000109000:
        settings.stream() << "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 (";
        break;
    case 1000109001:
        settings.stream() << "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 (";
        break;
    case 1000109002:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 (";
        break;
    case 1000109003:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 (";
        break;
    case 1000109004:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 (";
        break;
    case 1000109005:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO (";
        break;
    case 1000109006:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_END_INFO (";
        break;
    case 1000177000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES (";
        break;
    case 1000196000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES (";
        break;
    case 1000180000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES (";
        break;
    case 1000082000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES (";
        break;
    case 1000197000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES (";
        break;
    case 1000161000:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO (";
        break;
    case 1000161001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES (";
        break;
    case 1000161002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES (";
        break;
    case 1000161003:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO (";
        break;
    case 1000161004:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT (";
        break;
    case 1000199000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES (";
        break;
    case 1000199001:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE (";
        break;
    case 1000221000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES (";
        break;
    case 1000246000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO (";
        break;
    case 1000130000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES (";
        break;
    case 1000130001:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO (";
        break;
    case 1000211000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES (";
        break;
    case 1000108000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES (";
        break;
    case 1000108001:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO (";
        break;
    case 1000108002:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO (";
        break;
    case 1000108003:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO (";
        break;
    case 1000253000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES (";
        break;
    case 1000175000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES (";
        break;
    case 1000241000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES (";
        break;
    case 1000241001:
        settings.stream() << "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT (";
        break;
    case 1000241002:
        settings.stream() << "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT (";
        break;
    case 1000261000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES (";
        break;
    case 1000207000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES (";
        break;
    case 1000207001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES (";
        break;
    case 1000207002:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO (";
        break;
    case 1000207003:
        settings.stream() << "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO (";
        break;
    case 1000207004:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO (";
        break;
    case 1000207005:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO (";
        break;
    case 1000257000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES (";
        break;
    case 1000244001:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO (";
        break;
    case 1000257002:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO (";
        break;
    case 1000257003:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO (";
        break;
    case 1000257004:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO (";
        break;
    case 53:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES (";
        break;
    case 54:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES (";
        break;
    case 1000192000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO (";
        break;
    case 1000215000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES (";
        break;
    case 1000245000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES (";
        break;
    case 1000276000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES (";
        break;
    case 1000295000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES (";
        break;
    case 1000295001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO (";
        break;
    case 1000295002:
        settings.stream() << "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO (";
        break;
    case 1000297000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES (";
        break;
    case 1000314000:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 (";
        break;
    case 1000314001:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 (";
        break;
    case 1000314002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 (";
        break;
    case 1000314003:
        settings.stream() << "VK_STRUCTURE_TYPE_DEPENDENCY_INFO (";
        break;
    case 1000314004:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBMIT_INFO_2 (";
        break;
    case 1000314005:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO (";
        break;
    case 1000314006:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO (";
        break;
    case 1000314007:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES (";
        break;
    case 1000325000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES (";
        break;
    case 1000335000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES (";
        break;
    case 1000337000:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 (";
        break;
    case 1000337001:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 (";
        break;
    case 1000337002:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 (";
        break;
    case 1000337003:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 (";
        break;
    case 1000337004:
        settings.stream() << "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 (";
        break;
    case 1000337005:
        settings.stream() << "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 (";
        break;
    case 1000337006:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COPY_2 (";
        break;
    case 1000337007:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_COPY_2 (";
        break;
    case 1000337008:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_BLIT_2 (";
        break;
    case 1000337009:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 (";
        break;
    case 1000337010:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 (";
        break;
    case 1000225000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES (";
        break;
    case 1000225001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO (";
        break;
    case 1000225002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES (";
        break;
    case 1000138000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES (";
        break;
    case 1000138001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES (";
        break;
    case 1000138002:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK (";
        break;
    case 1000138003:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO (";
        break;
    case 1000066000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES (";
        break;
    case 1000044000:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_INFO (";
        break;
    case 1000044001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO (";
        break;
    case 1000044002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO (";
        break;
    case 1000044003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES (";
        break;
    case 1000044004:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO (";
        break;
    case 1000280000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES (";
        break;
    case 1000280001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES (";
        break;
    case 1000281001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES (";
        break;
    case 1000360000:
        settings.stream() << "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 (";
        break;
    case 1000413000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES (";
        break;
    case 1000413001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES (";
        break;
    case 1000413002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS (";
        break;
    case 1000413003:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS (";
        break;
    case 55:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES (";
        break;
    case 56:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES (";
        break;
    case 1000174000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO (";
        break;
    case 1000388000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES (";
        break;
    case 1000388001:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES (";
        break;
    case 1000416000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES (";
        break;
    case 1000528000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES (";
        break;
    case 1000544000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES (";
        break;
    case 1000259000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES (";
        break;
    case 1000259001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO (";
        break;
    case 1000259002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES (";
        break;
    case 1000525000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES (";
        break;
    case 1000190001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO (";
        break;
    case 1000190002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES (";
        break;
    case 1000265000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES (";
        break;
    case 1000271000:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO (";
        break;
    case 1000271001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO (";
        break;
    case 1000470000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES (";
        break;
    case 1000470001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES (";
        break;
    case 1000470003:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO (";
        break;
    case 1000470004:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO (";
        break;
    case 1000338002:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 (";
        break;
    case 1000338003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 (";
        break;
    case 1000470005:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO (";
        break;
    case 1000470006:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO (";
        break;
    case 1000080000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES (";
        break;
    case 1000232000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES (";
        break;
    case 1000232001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO (";
        break;
    case 1000232002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO (";
        break;
    case 1000545000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES (";
        break;
    case 1000545001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES (";
        break;
    case 1000545002:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS (";
        break;
    case 1000545003:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO (";
        break;
    case 1000545004:
        settings.stream() << "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO (";
        break;
    case 1000545005:
        settings.stream() << "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO (";
        break;
    case 1000545006:
        settings.stream() << "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO (";
        break;
    case 1000466000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES (";
        break;
    case 1000068000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO (";
        break;
    case 1000068001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES (";
        break;
    case 1000068002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES (";
        break;
    case 1000270000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES (";
        break;
    case 1000270001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES (";
        break;
    case 1000270002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY (";
        break;
    case 1000270003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY (";
        break;
    case 1000270004:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO (";
        break;
    case 1000270005:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO (";
        break;
    case 1000270006:
        settings.stream() << "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO (";
        break;
    case 1000270007:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO (";
        break;
    case 1000270008:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE (";
        break;
    case 1000270009:
        settings.stream() << "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY (";
        break;
    case 1000001000:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR (";
        break;
    case 1000001001:
        settings.stream() << "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR (";
        break;
    case 1000060007:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR (";
        break;
    case 1000060008:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR (";
        break;
    case 1000060009:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR (";
        break;
    case 1000060010:
        settings.stream() << "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR (";
        break;
    case 1000060011:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR (";
        break;
    case 1000060012:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR (";
        break;
    case 1000002000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR (";
        break;
    case 1000002001:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000003000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR (";
        break;
    case 1000004000:
        settings.stream() << "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000005000:
        settings.stream() << "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000006000:
        settings.stream() << "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000008000:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000009000:
        settings.stream() << "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR (";
        break;
    case 1000010000:
        settings.stream() << "VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID (";
        break;
    case 1000010001:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID (";
        break;
    case 1000010002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID (";
        break;
    case 1000011000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT (";
        break;
    case 1000018000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD (";
        break;
    case 1000022000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT (";
        break;
    case 1000022001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT (";
        break;
    case 1000022002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT (";
        break;
    case 1000023000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR (";
        break;
    case 1000023001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR (";
        break;
    case 1000023002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR (";
        break;
    case 1000023003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR (";
        break;
    case 1000023004:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR (";
        break;
    case 1000023005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR (";
        break;
    case 1000023006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000023007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR (";
        break;
    case 1000023008:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR (";
        break;
    case 1000023009:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR (";
        break;
    case 1000023010:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR (";
        break;
    case 1000023011:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR (";
        break;
    case 1000023012:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR (";
        break;
    case 1000023013:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR (";
        break;
    case 1000023014:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR (";
        break;
    case 1000023015:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR (";
        break;
    case 1000023016:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR (";
        break;
    case 1000024000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR (";
        break;
    case 1000024001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR (";
        break;
    case 1000024002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR (";
        break;
    case 1000026000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV (";
        break;
    case 1000026001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV (";
        break;
    case 1000026002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV (";
        break;
    case 1000028000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT (";
        break;
    case 1000028001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT (";
        break;
    case 1000028002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT (";
        break;
    case 1000029000:
        settings.stream() << "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX (";
        break;
    case 1000029001:
        settings.stream() << "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX (";
        break;
    case 1000029002:
        settings.stream() << "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX (";
        break;
    case 1000029004:
        settings.stream() << "VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX (";
        break;
    case 1000030000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX (";
        break;
    case 1000030001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX (";
        break;
    case 1000038000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR (";
        break;
    case 1000038001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000038002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR (";
        break;
    case 1000038003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR (";
        break;
    case 1000038004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR (";
        break;
    case 1000038005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR (";
        break;
    case 1000038006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR (";
        break;
    case 1000038007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR (";
        break;
    case 1000038008:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR (";
        break;
    case 1000038009:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR (";
        break;
    case 1000038010:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR (";
        break;
    case 1000038011:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR (";
        break;
    case 1000038012:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR (";
        break;
    case 1000038013:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR (";
        break;
    case 1000039000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR (";
        break;
    case 1000039001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000039002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR (";
        break;
    case 1000039003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR (";
        break;
    case 1000039004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR (";
        break;
    case 1000039005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR (";
        break;
    case 1000039006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR (";
        break;
    case 1000039007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR (";
        break;
    case 1000039009:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR (";
        break;
    case 1000039010:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR (";
        break;
    case 1000039011:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR (";
        break;
    case 1000039012:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR (";
        break;
    case 1000039013:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR (";
        break;
    case 1000039014:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR (";
        break;
    case 1000040000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR (";
        break;
    case 1000040001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR (";
        break;
    case 1000040003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR (";
        break;
    case 1000040004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000040005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR (";
        break;
    case 1000040006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR (";
        break;
    case 1000041000:
        settings.stream() << "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD (";
        break;
    case 1000049000:
        settings.stream() << "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP (";
        break;
    case 1000050000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV (";
        break;
    case 1000051000:
        settings.stream() << "VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_PLACEHOLDER_OFFSET_0_NV (";
        break;
    case 1000056000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV (";
        break;
    case 1000056001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV (";
        break;
    case 1000057000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV (";
        break;
    case 1000057001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV (";
        break;
    case 1000058000:
        settings.stream() << "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV (";
        break;
    case 1000061000:
        settings.stream() << "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT (";
        break;
    case 1000062000:
        settings.stream() << "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN (";
        break;
    case 1000067000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT (";
        break;
    case 1000067001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT (";
        break;
    case 1000073000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000073001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000073002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR (";
        break;
    case 1000073003:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000074000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR (";
        break;
    case 1000074001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR (";
        break;
    case 1000074002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR (";
        break;
    case 1000075000:
        settings.stream() << "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR (";
        break;
    case 1000078000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000078001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000078002:
        settings.stream() << "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR (";
        break;
    case 1000078003:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000079000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR (";
        break;
    case 1000079001:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR (";
        break;
    case 1000081000:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT (";
        break;
    case 1000081001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT (";
        break;
    case 1000081002:
        settings.stream() << "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT (";
        break;
    case 1000084000:
        settings.stream() << "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR (";
        break;
    case 1000087000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV (";
        break;
    case 1000090000:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT (";
        break;
    case 1000091000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT (";
        break;
    case 1000091001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT (";
        break;
    case 1000091002:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT (";
        break;
    case 1000091003:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT (";
        break;
    case 1000092000:
        settings.stream() << "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE (";
        break;
    case 1000097000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX (";
        break;
    case 1000044009:
        settings.stream() << "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX (";
        break;
    case 1000098000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV (";
        break;
    case 1000099000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT (";
        break;
    case 1000099001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT (";
        break;
    case 1000101000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT (";
        break;
    case 1000101001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT (";
        break;
    case 1000102000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT (";
        break;
    case 1000102001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT (";
        break;
    case 1000105000:
        settings.stream() << "VK_STRUCTURE_TYPE_HDR_METADATA_EXT (";
        break;
    case 1000110000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG (";
        break;
    case 1000111000:
        settings.stream() << "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR (";
        break;
    case 1000114000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000114001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000114002:
        settings.stream() << "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR (";
        break;
    case 1000115000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR (";
        break;
    case 1000115001:
        settings.stream() << "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR (";
        break;
    case 1000116000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR (";
        break;
    case 1000116001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR (";
        break;
    case 1000116002:
        settings.stream() << "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR (";
        break;
    case 1000116003:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR (";
        break;
    case 1000116004:
        settings.stream() << "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR (";
        break;
    case 1000116005:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR (";
        break;
    case 1000116006:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR (";
        break;
    case 1000119000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR (";
        break;
    case 1000119001:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR (";
        break;
    case 1000119002:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR (";
        break;
    case 1000121000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR (";
        break;
    case 1000121001:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR (";
        break;
    case 1000121002:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR (";
        break;
    case 1000121003:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR (";
        break;
    case 1000121004:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR (";
        break;
    case 1000122000:
        settings.stream() << "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK (";
        break;
    case 1000123000:
        settings.stream() << "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK (";
        break;
    case 1000128000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT (";
        break;
    case 1000128001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT (";
        break;
    case 1000128002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT (";
        break;
    case 1000128003:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT (";
        break;
    case 1000128004:
        settings.stream() << "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT (";
        break;
    case 1000129000:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID (";
        break;
    case 1000129001:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID (";
        break;
    case 1000129002:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID (";
        break;
    case 1000129003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID (";
        break;
    case 1000129004:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID (";
        break;
    case 1000129005:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID (";
        break;
    case 1000129006:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID (";
        break;
    case 1000134000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX (";
        break;
    case 1000134001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX (";
        break;
    case 1000134002:
        settings.stream() << "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX (";
        break;
    case 1000134003:
        settings.stream() << "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX (";
        break;
    case 1000134004:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX (";
        break;
    case 1000044008:
        settings.stream() << "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD (";
        break;
    case 1000141000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR (";
        break;
    case 1000143000:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT (";
        break;
    case 1000143001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT (";
        break;
    case 1000143002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT (";
        break;
    case 1000143003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT (";
        break;
    case 1000143004:
        settings.stream() << "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT (";
        break;
    case 1000148000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT (";
        break;
    case 1000148001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT (";
        break;
    case 1000148002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT (";
        break;
    case 1000149000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV (";
        break;
    case 1000150007:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR (";
        break;
    case 1000150000:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR (";
        break;
    case 1000150002:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR (";
        break;
    case 1000150003:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR (";
        break;
    case 1000150004:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR (";
        break;
    case 1000150005:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR (";
        break;
    case 1000150006:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR (";
        break;
    case 1000150009:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR (";
        break;
    case 1000150010:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR (";
        break;
    case 1000150011:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR (";
        break;
    case 1000150012:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR (";
        break;
    case 1000150013:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR (";
        break;
    case 1000150014:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR (";
        break;
    case 1000150017:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR (";
        break;
    case 1000150020:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR (";
        break;
    case 1000347000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR (";
        break;
    case 1000347001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR (";
        break;
    case 1000150015:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR (";
        break;
    case 1000150016:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR (";
        break;
    case 1000150018:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR (";
        break;
    case 1000348013:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR (";
        break;
    case 1000152000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV (";
        break;
    case 1000154000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV (";
        break;
    case 1000154001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV (";
        break;
    case 1000158000:
        settings.stream() << "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT (";
        break;
    case 1000158002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT (";
        break;
    case 1000158003:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT (";
        break;
    case 1000158004:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT (";
        break;
    case 1000158005:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT (";
        break;
    case 1000158006:
        settings.stream() << "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT (";
        break;
    case 1000160000:
        settings.stream() << "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT (";
        break;
    case 1000160001:
        settings.stream() << "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT (";
        break;
    case 1000163000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR (";
        break;
    case 1000163001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR (";
        break;
    case 1000164000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV (";
        break;
    case 1000164001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV (";
        break;
    case 1000164002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV (";
        break;
    case 1000164005:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV (";
        break;
    case 1000165000:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV (";
        break;
    case 1000165001:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV (";
        break;
    case 1000165003:
        settings.stream() << "VK_STRUCTURE_TYPE_GEOMETRY_NV (";
        break;
    case 1000165004:
        settings.stream() << "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV (";
        break;
    case 1000165005:
        settings.stream() << "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV (";
        break;
    case 1000165006:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV (";
        break;
    case 1000165007:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV (";
        break;
    case 1000165008:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV (";
        break;
    case 1000165009:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV (";
        break;
    case 1000165011:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV (";
        break;
    case 1000165012:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV (";
        break;
    case 1000166000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV (";
        break;
    case 1000166001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV (";
        break;
    case 1000170000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT (";
        break;
    case 1000170001:
        settings.stream() << "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT (";
        break;
    case 1000178000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT (";
        break;
    case 1000178001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT (";
        break;
    case 1000178002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT (";
        break;
    case 1000181000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR (";
        break;
    case 1000183000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD (";
        break;
    case 1000185000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD (";
        break;
    case 1000187000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR (";
        break;
    case 1000187001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000187002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR (";
        break;
    case 1000187003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR (";
        break;
    case 1000187004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR (";
        break;
    case 1000187005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR (";
        break;
    case 1000189000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD (";
        break;
    case 1000190000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT (";
        break;
    case 1000191000:
        settings.stream() << "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP (";
        break;
    case 1000202000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV (";
        break;
    case 1000202001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV (";
        break;
    case 1000204000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV (";
        break;
    case 1000205000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV (";
        break;
    case 1000205002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV (";
        break;
    case 1000206000:
        settings.stream() << "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV (";
        break;
    case 1000206001:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV (";
        break;
    case 1000314008:
        settings.stream() << "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV (";
        break;
    case 1000314009:
        settings.stream() << "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV (";
        break;
    case 1000209000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL (";
        break;
    case 1000210000:
        settings.stream() << "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL (";
        break;
    case 1000210001:
        settings.stream() << "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL (";
        break;
    case 1000210002:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL (";
        break;
    case 1000210003:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL (";
        break;
    case 1000210004:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL (";
        break;
    case 1000210005:
        settings.stream() << "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL (";
        break;
    case 1000212000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT (";
        break;
    case 1000213000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD (";
        break;
    case 1000213001:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD (";
        break;
    case 1000214000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA (";
        break;
    case 1000217000:
        settings.stream() << "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT (";
        break;
    case 1000218000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT (";
        break;
    case 1000218001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT (";
        break;
    case 1000218002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT (";
        break;
    case 1000044007:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT (";
        break;
    case 1000226000:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR (";
        break;
    case 1000226001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR (";
        break;
    case 1000226002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR (";
        break;
    case 1000226003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR (";
        break;
    case 1000226004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR (";
        break;
    case 1000044006:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR (";
        break;
    case 1000227000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD (";
        break;
    case 1000229000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD (";
        break;
    case 1000234000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT (";
        break;
    case 1000235000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR (";
        break;
    case 1000237000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT (";
        break;
    case 1000238000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT (";
        break;
    case 1000238001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT (";
        break;
    case 1000239000:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR (";
        break;
    case 1000240000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV (";
        break;
    case 1000244000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT (";
        break;
    case 1000244002:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT (";
        break;
    case 1000247000:
        settings.stream() << "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT (";
        break;
    case 1000248000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR (";
        break;
    case 1000249000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV (";
        break;
    case 1000249001:
        settings.stream() << "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV (";
        break;
    case 1000249002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV (";
        break;
    case 1000250000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV (";
        break;
    case 1000250001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV (";
        break;
    case 1000250002:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV (";
        break;
    case 1000251000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT (";
        break;
    case 1000252000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT (";
        break;
    case 1000254000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT (";
        break;
    case 1000254001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT (";
        break;
    case 1000254002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT (";
        break;
    case 1000255000:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT (";
        break;
    case 1000255002:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT (";
        break;
    case 1000255001:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT (";
        break;
    case 1000256000:
        settings.stream() << "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT (";
        break;
    case 1000260000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT (";
        break;
    case 1000267000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT (";
        break;
    case 1000269000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR (";
        break;
    case 1000269001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR (";
        break;
    case 1000269002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR (";
        break;
    case 1000269003:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR (";
        break;
    case 1000269004:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR (";
        break;
    case 1000269005:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR (";
        break;
    case 1000272000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT (";
        break;
    case 1000272001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT (";
        break;
    case 1000272002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT (";
        break;
    case 1000273000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT (";
        break;
    case 1000274000:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT (";
        break;
    case 1000274001:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT (";
        break;
    case 1000274002:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT (";
        break;
    case 1000275000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT (";
        break;
    case 1000275001:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT (";
        break;
    case 1000275002:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT (";
        break;
    case 1000275003:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT (";
        break;
    case 1000275004:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT (";
        break;
    case 1000275005:
        settings.stream() << "VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT (";
        break;
    case 1000277000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV (";
        break;
    case 1000277001:
        settings.stream() << "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV (";
        break;
    case 1000277002:
        settings.stream() << "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV (";
        break;
    case 1000277003:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV (";
        break;
    case 1000277004:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV (";
        break;
    case 1000277005:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV (";
        break;
    case 1000277006:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV (";
        break;
    case 1000277007:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV (";
        break;
    case 1000278000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV (";
        break;
    case 1000278001:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV (";
        break;
    case 1000281000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT (";
        break;
    case 1000282000:
        settings.stream() << "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM (";
        break;
    case 1000282001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM (";
        break;
    case 1000283000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT (";
        break;
    case 1000283001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT (";
        break;
    case 1000283002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT (";
        break;
    case 1000284000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT (";
        break;
    case 1000284001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT (";
        break;
    case 1000284002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT (";
        break;
    case 1000286000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT (";
        break;
    case 1000286001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT (";
        break;
    case 1000287000:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT (";
        break;
    case 1000287001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT (";
        break;
    case 1000287002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT (";
        break;
    case 1000290000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR (";
        break;
    case 1000292000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV (";
        break;
    case 1000292001:
        settings.stream() << "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV (";
        break;
    case 1000292002:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV (";
        break;
    case 1000294000:
        settings.stream() << "VK_STRUCTURE_TYPE_PRESENT_ID_KHR (";
        break;
    case 1000294001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR (";
        break;
    case 1000299000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR (";
        break;
    case 1000299001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR (";
        break;
    case 1000299002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR (";
        break;
    case 1000299003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR (";
        break;
    case 1000299004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR (";
        break;
    case 1000299005:
        settings.stream() << "VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR (";
        break;
    case 1000299006:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR (";
        break;
    case 1000299007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR (";
        break;
    case 1000299008:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR (";
        break;
    case 1000299009:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR (";
        break;
    case 1000299010:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR (";
        break;
    case 1000300000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV (";
        break;
    case 1000300001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV (";
        break;
    case 1000307000:
        settings.stream() << "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV (";
        break;
    case 1000307001:
        settings.stream() << "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV (";
        break;
    case 1000307002:
        settings.stream() << "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV (";
        break;
    case 1000307003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV (";
        break;
    case 1000307004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV (";
        break;
    case 1000308000:
        settings.stream() << "VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR (";
        break;
    case 1000309000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM (";
        break;
    case 1000309001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM (";
        break;
    case 1000309002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM (";
        break;
    case 1000309003:
        settings.stream() << "VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM (";
        break;
    case 1000309004:
        settings.stream() << "VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM (";
        break;
    case 1000309005:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM (";
        break;
    case 1000310000:
        settings.stream() << "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV (";
        break;
    case 1000311000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT (";
        break;
    case 1000311001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT (";
        break;
    case 1000311002:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT (";
        break;
    case 1000311003:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT (";
        break;
    case 1000311004:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT (";
        break;
    case 1000311005:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT (";
        break;
    case 1000311006:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT (";
        break;
    case 1000311007:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT (";
        break;
    case 1000311008:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT (";
        break;
    case 1000311009:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT (";
        break;
    case 1000311010:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT (";
        break;
    case 1000311011:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT (";
        break;
    case 1000316000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT (";
        break;
    case 1000316001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT (";
        break;
    case 1000316002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT (";
        break;
    case 1000316003:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT (";
        break;
    case 1000316004:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT (";
        break;
    case 1000316005:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT (";
        break;
    case 1000316006:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT (";
        break;
    case 1000316007:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT (";
        break;
    case 1000316008:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT (";
        break;
    case 1000316010:
        settings.stream() << "VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT (";
        break;
    case 1000316011:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT (";
        break;
    case 1000316012:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT (";
        break;
    case 1000316009:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT (";
        break;
    case 1000320000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT (";
        break;
    case 1000320001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT (";
        break;
    case 1000320002:
        settings.stream() << "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT (";
        break;
    case 1000321000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD (";
        break;
    case 1000203000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR (";
        break;
    case 1000322000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR (";
        break;
    case 1000323000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR (";
        break;
    case 1000326000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV (";
        break;
    case 1000326001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV (";
        break;
    case 1000326002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV (";
        break;
    case 1000327000:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV (";
        break;
    case 1000327001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV (";
        break;
    case 1000327002:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV (";
        break;
    case 1000328000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT (";
        break;
    case 1000328001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT (";
        break;
    case 1000330000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT (";
        break;
    case 1000332000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT (";
        break;
    case 1000332001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT (";
        break;
    case 1000333000:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM (";
        break;
    case 1000336000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR (";
        break;
    case 1000338000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT (";
        break;
    case 1000338001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT (";
        break;
    case 1000338004:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT (";
        break;
    case 1000339000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT (";
        break;
    case 1000340000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT (";
        break;
    case 1000341000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT (";
        break;
    case 1000341001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT (";
        break;
    case 1000341002:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT (";
        break;
    case 1000344000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT (";
        break;
    case 1000346000:
        settings.stream() << "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT (";
        break;
    case 1000352000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT (";
        break;
    case 1000352001:
        settings.stream() << "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT (";
        break;
    case 1000352002:
        settings.stream() << "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT (";
        break;
    case 1000353000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT (";
        break;
    case 1000354000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT (";
        break;
    case 1000354001:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT (";
        break;
    case 1000355000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT (";
        break;
    case 1000355001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT (";
        break;
    case 1000356000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT (";
        break;
    case 1000361000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT (";
        break;
    case 1000364000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA (";
        break;
    case 1000364001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA (";
        break;
    case 1000364002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA (";
        break;
    case 1000365000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA (";
        break;
    case 1000365001:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA (";
        break;
    case 1000366000:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA (";
        break;
    case 1000366001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA (";
        break;
    case 1000366002:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA (";
        break;
    case 1000366003:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA (";
        break;
    case 1000366004:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA (";
        break;
    case 1000366005:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA (";
        break;
    case 1000366006:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA (";
        break;
    case 1000366007:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA (";
        break;
    case 1000366008:
        settings.stream() << "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA (";
        break;
    case 1000366009:
        settings.stream() << "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA (";
        break;
    case 1000369000:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI (";
        break;
    case 1000369001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI (";
        break;
    case 1000369002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI (";
        break;
    case 1000370000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI (";
        break;
    case 1000371000:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV (";
        break;
    case 1000371001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV (";
        break;
    case 1000372000:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT (";
        break;
    case 1000372001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT (";
        break;
    case 1000373000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV (";
        break;
    case 1000373001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV (";
        break;
    case 1000373002:
        settings.stream() << "VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV (";
        break;
    case 1000373003:
        settings.stream() << "VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV (";
        break;
    case 1000373004:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV (";
        break;
    case 1000373005:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV (";
        break;
    case 1000373006:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV (";
        break;
    case 1000373007:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV (";
        break;
    case 1000374000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV (";
        break;
    case 1000374001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV (";
        break;
    case 1000374002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV (";
        break;
    case 1000374003:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV (";
        break;
    case 1000374004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV (";
        break;
    case 1000375000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT (";
        break;
    case 1000375001:
        settings.stream() << "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT (";
        break;
    case 1000376000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT (";
        break;
    case 1000376001:
        settings.stream() << "VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT (";
        break;
    case 1000376002:
        settings.stream() << "VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT (";
        break;
    case 1000377000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT (";
        break;
    case 1000378000:
        settings.stream() << "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX (";
        break;
    case 1000381000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT (";
        break;
    case 1000381001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT (";
        break;
    case 1000382000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT (";
        break;
    case 1000386000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR (";
        break;
    case 1000391000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT (";
        break;
    case 1000391001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT (";
        break;
    case 1000392000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT (";
        break;
    case 1000392001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT (";
        break;
    case 1000393000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT (";
        break;
    case 1000395000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT (";
        break;
    case 1000395001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT (";
        break;
    case 1000396000:
        settings.stream() << "VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT (";
        break;
    case 1000396001:
        settings.stream() << "VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT (";
        break;
    case 1000396002:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT (";
        break;
    case 1000396003:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT (";
        break;
    case 1000396004:
        settings.stream() << "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT (";
        break;
    case 1000396005:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT (";
        break;
    case 1000396006:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT (";
        break;
    case 1000396007:
        settings.stream() << "VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT (";
        break;
    case 1000396008:
        settings.stream() << "VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT (";
        break;
    case 1000396009:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT (";
        break;
    case 1000397000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV (";
        break;
    case 1000397001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV (";
        break;
    case 1000397002:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV (";
        break;
    case 1000404000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI (";
        break;
    case 1000404001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI (";
        break;
    case 1000404002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI (";
        break;
    case 1000411000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT (";
        break;
    case 1000411001:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT (";
        break;
    case 1000412000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT (";
        break;
    case 1000415000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM (";
        break;
    case 1000417000:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM (";
        break;
    case 1000417001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM (";
        break;
    case 1000417002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM (";
        break;
    case 1000418000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT (";
        break;
    case 1000418001:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT (";
        break;
    case 1000420000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE (";
        break;
    case 1000420001:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE (";
        break;
    case 1000420002:
        settings.stream() << "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE (";
        break;
    case 1000422000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT (";
        break;
    case 1000424000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM (";
        break;
    case 1000424001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM (";
        break;
    case 1000424002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM (";
        break;
    case 1000424003:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM (";
        break;
    case 1000424004:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM (";
        break;
    case 1000426000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV (";
        break;
    case 1000426001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV (";
        break;
    case 1000427000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV (";
        break;
    case 1000427001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV (";
        break;
    case 1000428000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV (";
        break;
    case 1000428001:
        settings.stream() << "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV (";
        break;
    case 1000428002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV (";
        break;
    case 1000429008:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV (";
        break;
    case 1000429009:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV (";
        break;
    case 1000429010:
        settings.stream() << "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV (";
        break;
    case 1000430000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV (";
        break;
    case 1000434000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR (";
        break;
    case 1000435000:
        settings.stream() << "VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT (";
        break;
    case 1000437000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT (";
        break;
    case 1000440000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM (";
        break;
    case 1000440001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM (";
        break;
    case 1000440002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM (";
        break;
    case 1000451000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT (";
        break;
    case 1000451001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT (";
        break;
    case 1000453000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT (";
        break;
    case 1000455000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT (";
        break;
    case 1000455001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT (";
        break;
    case 1000458000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT (";
        break;
    case 1000458001:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT (";
        break;
    case 1000458002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT (";
        break;
    case 1000458003:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT (";
        break;
    case 1000459000:
        settings.stream() << "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG (";
        break;
    case 1000459001:
        settings.stream() << "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG (";
        break;
    case 1000462000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT (";
        break;
    case 1000462001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT (";
        break;
    case 1000462002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT (";
        break;
    case 1000462003:
        settings.stream() << "VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT (";
        break;
    case 1000342000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT (";
        break;
    case 1000464000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV (";
        break;
    case 1000464001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV (";
        break;
    case 1000464002:
        settings.stream() << "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV (";
        break;
    case 1000464003:
        settings.stream() << "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV (";
        break;
    case 1000464004:
        settings.stream() << "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV (";
        break;
    case 1000464005:
        settings.stream() << "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV (";
        break;
    case 1000464010:
        settings.stream() << "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV (";
        break;
    case 1000465000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT (";
        break;
    case 1000468000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID (";
        break;
    case 1000468001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID (";
        break;
    case 1000468002:
        settings.stream() << "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID (";
        break;
    case 1000476000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD (";
        break;
    case 1000476001:
        settings.stream() << "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD (";
        break;
    case 1000476002:
        settings.stream() << "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD (";
        break;
    case 1000481000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR (";
        break;
    case 1000482000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT (";
        break;
    case 1000482001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT (";
        break;
    case 1000482002:
        settings.stream() << "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT (";
        break;
    case 1000483000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR (";
        break;
    case 1000483001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR (";
        break;
    case 1000483002:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR (";
        break;
    case 1000483003:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR (";
        break;
    case 1000483004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR (";
        break;
    case 1000483005:
        settings.stream() << "VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR (";
        break;
    case 1000483006:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR (";
        break;
    case 1000483007:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR (";
        break;
    case 1000483008:
        settings.stream() << "VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR (";
        break;
    case 1000483009:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR (";
        break;
    case 1000484000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM (";
        break;
    case 1000484001:
        settings.stream() << "VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM (";
        break;
    case 1000485000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC (";
        break;
    case 1000485001:
        settings.stream() << "VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC (";
        break;
    case 1000488000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM (";
        break;
    case 1000489000:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV (";
        break;
    case 1000489001:
        settings.stream() << "VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV (";
        break;
    case 1000489002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV (";
        break;
    case 1000490000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV (";
        break;
    case 1000490001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV (";
        break;
    case 1000491000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV (";
        break;
    case 1000491001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV (";
        break;
    case 1000491002:
        settings.stream() << "VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV (";
        break;
    case 1000491004:
        settings.stream() << "VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV (";
        break;
    case 1000492000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV (";
        break;
    case 1000492001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV (";
        break;
    case 1000351000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT (";
        break;
    case 1000351002:
        settings.stream() << "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT (";
        break;
    case 1000495000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT (";
        break;
    case 1000495001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT (";
        break;
    case 1000496000:
        settings.stream() << "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT (";
        break;
    case 1000497000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM (";
        break;
    case 1000497001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM (";
        break;
    case 1000498000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT (";
        break;
    case 1000499000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT (";
        break;
    case 1000505000:
        settings.stream() << "VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV (";
        break;
    case 1000505001:
        settings.stream() << "VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV (";
        break;
    case 1000505002:
        settings.stream() << "VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV (";
        break;
    case 1000505003:
        settings.stream() << "VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV (";
        break;
    case 1000505004:
        settings.stream() << "VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV (";
        break;
    case 1000505005:
        settings.stream() << "VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV (";
        break;
    case 1000505006:
        settings.stream() << "VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV (";
        break;
    case 1000505007:
        settings.stream() << "VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV (";
        break;
    case 1000505008:
        settings.stream() << "VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV (";
        break;
    case 1000506000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR (";
        break;
    case 1000506001:
        settings.stream() << "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR (";
        break;
    case 1000506002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR (";
        break;
    case 1000510000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM (";
        break;
    case 1000510001:
        settings.stream() << "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM (";
        break;
    case 1000201000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR (";
        break;
    case 1000511000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR (";
        break;
    case 1000512000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR (";
        break;
    case 1000512001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR (";
        break;
    case 1000512003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR (";
        break;
    case 1000512004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000512005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR (";
        break;
    case 1000513000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR (";
        break;
    case 1000513001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000513002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR (";
        break;
    case 1000513003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR (";
        break;
    case 1000513004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR (";
        break;
    case 1000513005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR (";
        break;
    case 1000513006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR (";
        break;
    case 1000513007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR (";
        break;
    case 1000513008:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR (";
        break;
    case 1000513009:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR (";
        break;
    case 1000513010:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR (";
        break;
    case 1000515000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR (";
        break;
    case 1000515001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR (";
        break;
    case 1000516000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV (";
        break;
    case 1000518000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM (";
        break;
    case 1000518001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM (";
        break;
    case 1000518002:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM (";
        break;
    case 1000519000:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM (";
        break;
    case 1000519001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM (";
        break;
    case 1000519002:
        settings.stream() << "VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM (";
        break;
    case 1000520000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM (";
        break;
    case 1000520001:
        settings.stream() << "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM (";
        break;
    case 1000521000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM (";
        break;
    case 1000524000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT (";
        break;
    case 1000529000:
        settings.stream() << "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX (";
        break;
    case 1000529001:
        settings.stream() << "VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX (";
        break;
    case 1000529002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX (";
        break;
    case 1000529003:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX (";
        break;
    case 1000529004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX (";
        break;
    case 1000530000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT (";
        break;
    case 1000184000:
        settings.stream() << "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR (";
        break;
    case 1000545007:
        settings.stream() << "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT (";
        break;
    case 1000545008:
        settings.stream() << "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT (";
        break;
    case 1000546000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV (";
        break;
    case 1000547000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM (";
        break;
    case 1000547001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM (";
        break;
    case 1000547002:
        settings.stream() << "VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM (";
        break;
    case 1000547003:
        settings.stream() << "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM (";
        break;
    case 1000547004:
        settings.stream() << "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM (";
        break;
    case 1000551000:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV (";
        break;
    case 1000551001:
        settings.stream() << "VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV (";
        break;
    case 1000553000:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR (";
        break;
    case 1000553001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR (";
        break;
    case 1000553002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR (";
        break;
    case 1000553005:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR (";
        break;
    case 1000553009:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR (";
        break;
    case 1000553003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR (";
        break;
    case 1000553004:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR (";
        break;
    case 1000553006:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR (";
        break;
    case 1000553007:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR (";
        break;
    case 1000553008:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR (";
        break;
    case 1000555000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV (";
        break;
    case 1000556000:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV (";
        break;
    case 1000556001:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV (";
        break;
    case 1000556002:
        settings.stream() << "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV (";
        break;
    case 1000556003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV (";
        break;
    case 1000558000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR (";
        break;
    case 1000559000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV (";
        break;
    case 1000562000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR (";
        break;
    case 1000562001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR (";
        break;
    case 1000562002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR (";
        break;
    case 1000562003:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR (";
        break;
    case 1000562004:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR (";
        break;
    case 1000563000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV (";
        break;
    case 1000564000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT (";
        break;
    case 1000568000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV (";
        break;
    case 1000569000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV (";
        break;
    case 1000569001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV (";
        break;
    case 1000569002:
        settings.stream() << "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV (";
        break;
    case 1000569003:
        settings.stream() << "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV (";
        break;
    case 1000569004:
        settings.stream() << "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV (";
        break;
    case 1000569005:
        settings.stream() << "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV (";
        break;
    case 1000569006:
        settings.stream() << "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV (";
        break;
    case 1000569007:
        settings.stream() << "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV (";
        break;
    case 1000570000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV (";
        break;
    case 1000570001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV (";
        break;
    case 1000570002:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV (";
        break;
    case 1000570003:
        settings.stream() << "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV (";
        break;
    case 1000570004:
        settings.stream() << "VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV (";
        break;
    case 1000570005:
        settings.stream() << "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV (";
        break;
    case 1000572000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT (";
        break;
    case 1000572001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT (";
        break;
    case 1000572002:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT (";
        break;
    case 1000572003:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT (";
        break;
    case 1000572004:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT (";
        break;
    case 1000572006:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT (";
        break;
    case 1000572007:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT (";
        break;
    case 1000572008:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT (";
        break;
    case 1000572009:
        settings.stream() << "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT (";
        break;
    case 1000572010:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT (";
        break;
    case 1000572011:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT (";
        break;
    case 1000572012:
        settings.stream() << "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT (";
        break;
    case 1000572013:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT (";
        break;
    case 1000572014:
        settings.stream() << "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT (";
        break;
    case 1000574000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR (";
        break;
    case 1000574002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR (";
        break;
    case 1000575000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA (";
        break;
    case 1000575001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA (";
        break;
    case 1000575002:
        settings.stream() << "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA (";
        break;
    case 1000582000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT (";
        break;
    case 1000582001:
        settings.stream() << "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT (";
        break;
    case 1000586000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR (";
        break;
    case 1000586001:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR (";
        break;
    case 1000586002:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR (";
        break;
    case 1000586003:
        settings.stream() << "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR (";
        break;
    case 1000590000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI (";
        break;
    case 1000590001:
        settings.stream() << "VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI (";
        break;
    case 1000593000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV (";
        break;
    case 1000593001:
        settings.stream() << "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV (";
        break;
    case 1000593002:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV (";
        break;
    case 1000596000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM (";
        break;
    case 1000602000:
        settings.stream() << "VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT (";
        break;
    case 1000602001:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT (";
        break;
    case 1000602002:
        settings.stream() << "VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT (";
        break;
    case 1000421000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR (";
        break;
    case 1000608000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT (";
        break;
    case 1000613000:
        settings.stream() << "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV (";
        break;
    case 1000613001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV (";
        break;
    case 1000425000:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT (";
        break;
    case 1000425001:
        settings.stream() << "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT (";
        break;
    case 1000425002:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT (";
        break;
    case 1000619003:
        settings.stream() << "VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPipelineCacheHeaderVersion(VkPipelineCacheHeaderVersion object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_PIPELINE_CACHE_HEADER_VERSION_ONE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkImageLayout(VkImageLayout object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_IMAGE_LAYOUT_UNDEFINED (";
        break;
    case 1:
        settings.stream() << "VK_IMAGE_LAYOUT_GENERAL (";
        break;
    case 2:
        settings.stream() << "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL (";
        break;
    case 3:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL (";
        break;
    case 4:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL (";
        break;
    case 5:
        settings.stream() << "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL (";
        break;
    case 6:
        settings.stream() << "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL (";
        break;
    case 7:
        settings.stream() << "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL (";
        break;
    case 8:
        settings.stream() << "VK_IMAGE_LAYOUT_PREINITIALIZED (";
        break;
    case 1000117000:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL (";
        break;
    case 1000117001:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL (";
        break;
    case 1000241000:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL (";
        break;
    case 1000241001:
        settings.stream() << "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL (";
        break;
    case 1000241002:
        settings.stream() << "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL (";
        break;
    case 1000241003:
        settings.stream() << "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL (";
        break;
    case 1000314000:
        settings.stream() << "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL (";
        break;
    case 1000314001:
        settings.stream() << "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL (";
        break;
    case 1000232000:
        settings.stream() << "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ (";
        break;
    case 1000001002:
        settings.stream() << "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR (";
        break;
    case 1000024000:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR (";
        break;
    case 1000024001:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR (";
        break;
    case 1000024002:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR (";
        break;
    case 1000111000:
        settings.stream() << "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR (";
        break;
    case 1000218000:
        settings.stream() << "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT (";
        break;
    case 1000164003:
        settings.stream() << "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR (";
        break;
    case 1000299000:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR (";
        break;
    case 1000299001:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR (";
        break;
    case 1000299002:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR (";
        break;
    case 1000339000:
        settings.stream() << "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT (";
        break;
    case 1000553000:
        settings.stream() << "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkObjectType(VkObjectType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_OBJECT_TYPE_UNKNOWN (";
        break;
    case 1:
        settings.stream() << "VK_OBJECT_TYPE_INSTANCE (";
        break;
    case 2:
        settings.stream() << "VK_OBJECT_TYPE_PHYSICAL_DEVICE (";
        break;
    case 3:
        settings.stream() << "VK_OBJECT_TYPE_DEVICE (";
        break;
    case 4:
        settings.stream() << "VK_OBJECT_TYPE_QUEUE (";
        break;
    case 5:
        settings.stream() << "VK_OBJECT_TYPE_SEMAPHORE (";
        break;
    case 6:
        settings.stream() << "VK_OBJECT_TYPE_COMMAND_BUFFER (";
        break;
    case 7:
        settings.stream() << "VK_OBJECT_TYPE_FENCE (";
        break;
    case 8:
        settings.stream() << "VK_OBJECT_TYPE_DEVICE_MEMORY (";
        break;
    case 9:
        settings.stream() << "VK_OBJECT_TYPE_BUFFER (";
        break;
    case 10:
        settings.stream() << "VK_OBJECT_TYPE_IMAGE (";
        break;
    case 11:
        settings.stream() << "VK_OBJECT_TYPE_EVENT (";
        break;
    case 12:
        settings.stream() << "VK_OBJECT_TYPE_QUERY_POOL (";
        break;
    case 13:
        settings.stream() << "VK_OBJECT_TYPE_BUFFER_VIEW (";
        break;
    case 14:
        settings.stream() << "VK_OBJECT_TYPE_IMAGE_VIEW (";
        break;
    case 15:
        settings.stream() << "VK_OBJECT_TYPE_SHADER_MODULE (";
        break;
    case 16:
        settings.stream() << "VK_OBJECT_TYPE_PIPELINE_CACHE (";
        break;
    case 17:
        settings.stream() << "VK_OBJECT_TYPE_PIPELINE_LAYOUT (";
        break;
    case 18:
        settings.stream() << "VK_OBJECT_TYPE_RENDER_PASS (";
        break;
    case 19:
        settings.stream() << "VK_OBJECT_TYPE_PIPELINE (";
        break;
    case 20:
        settings.stream() << "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT (";
        break;
    case 21:
        settings.stream() << "VK_OBJECT_TYPE_SAMPLER (";
        break;
    case 22:
        settings.stream() << "VK_OBJECT_TYPE_DESCRIPTOR_POOL (";
        break;
    case 23:
        settings.stream() << "VK_OBJECT_TYPE_DESCRIPTOR_SET (";
        break;
    case 24:
        settings.stream() << "VK_OBJECT_TYPE_FRAMEBUFFER (";
        break;
    case 25:
        settings.stream() << "VK_OBJECT_TYPE_COMMAND_POOL (";
        break;
    case 1000156000:
        settings.stream() << "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION (";
        break;
    case 1000085000:
        settings.stream() << "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE (";
        break;
    case 1000295000:
        settings.stream() << "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT (";
        break;
    case 1000000000:
        settings.stream() << "VK_OBJECT_TYPE_SURFACE_KHR (";
        break;
    case 1000001000:
        settings.stream() << "VK_OBJECT_TYPE_SWAPCHAIN_KHR (";
        break;
    case 1000002000:
        settings.stream() << "VK_OBJECT_TYPE_DISPLAY_KHR (";
        break;
    case 1000002001:
        settings.stream() << "VK_OBJECT_TYPE_DISPLAY_MODE_KHR (";
        break;
    case 1000011000:
        settings.stream() << "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT (";
        break;
    case 1000023000:
        settings.stream() << "VK_OBJECT_TYPE_VIDEO_SESSION_KHR (";
        break;
    case 1000023001:
        settings.stream() << "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR (";
        break;
    case 1000029000:
        settings.stream() << "VK_OBJECT_TYPE_CU_MODULE_NVX (";
        break;
    case 1000029001:
        settings.stream() << "VK_OBJECT_TYPE_CU_FUNCTION_NVX (";
        break;
    case 1000128000:
        settings.stream() << "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT (";
        break;
    case 1000150000:
        settings.stream() << "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR (";
        break;
    case 1000160000:
        settings.stream() << "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT (";
        break;
    case 1000165000:
        settings.stream() << "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV (";
        break;
    case 1000210000:
        settings.stream() << "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL (";
        break;
    case 1000268000:
        settings.stream() << "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR (";
        break;
    case 1000277000:
        settings.stream() << "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV (";
        break;
    case 1000307000:
        settings.stream() << "VK_OBJECT_TYPE_CUDA_MODULE_NV (";
        break;
    case 1000307001:
        settings.stream() << "VK_OBJECT_TYPE_CUDA_FUNCTION_NV (";
        break;
    case 1000366000:
        settings.stream() << "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA (";
        break;
    case 1000396000:
        settings.stream() << "VK_OBJECT_TYPE_MICROMAP_EXT (";
        break;
    case 1000464000:
        settings.stream() << "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV (";
        break;
    case 1000482000:
        settings.stream() << "VK_OBJECT_TYPE_SHADER_EXT (";
        break;
    case 1000483000:
        settings.stream() << "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR (";
        break;
    case 1000489000:
        settings.stream() << "VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV (";
        break;
    case 1000556000:
        settings.stream() << "VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV (";
        break;
    case 1000572000:
        settings.stream() << "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT (";
        break;
    case 1000572001:
        settings.stream() << "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkVendorId(VkVendorId object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0x10000:
        settings.stream() << "VK_VENDOR_ID_KHRONOS (";
        break;
    case 0x10001:
        settings.stream() << "VK_VENDOR_ID_VIV (";
        break;
    case 0x10002:
        settings.stream() << "VK_VENDOR_ID_VSI (";
        break;
    case 0x10003:
        settings.stream() << "VK_VENDOR_ID_KAZAN (";
        break;
    case 0x10004:
        settings.stream() << "VK_VENDOR_ID_CODEPLAY (";
        break;
    case 0x10005:
        settings.stream() << "VK_VENDOR_ID_MESA (";
        break;
    case 0x10006:
        settings.stream() << "VK_VENDOR_ID_POCL (";
        break;
    case 0x10007:
        settings.stream() << "VK_VENDOR_ID_MOBILEYE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSystemAllocationScope(VkSystemAllocationScope object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND (";
        break;
    case 1:
        settings.stream() << "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT (";
        break;
    case 2:
        settings.stream() << "VK_SYSTEM_ALLOCATION_SCOPE_CACHE (";
        break;
    case 3:
        settings.stream() << "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE (";
        break;
    case 4:
        settings.stream() << "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkInternalAllocationType(VkInternalAllocationType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFormat(VkFormat object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FORMAT_UNDEFINED (";
        break;
    case 1:
        settings.stream() << "VK_FORMAT_R4G4_UNORM_PACK8 (";
        break;
    case 2:
        settings.stream() << "VK_FORMAT_R4G4B4A4_UNORM_PACK16 (";
        break;
    case 3:
        settings.stream() << "VK_FORMAT_B4G4R4A4_UNORM_PACK16 (";
        break;
    case 4:
        settings.stream() << "VK_FORMAT_R5G6B5_UNORM_PACK16 (";
        break;
    case 5:
        settings.stream() << "VK_FORMAT_B5G6R5_UNORM_PACK16 (";
        break;
    case 6:
        settings.stream() << "VK_FORMAT_R5G5B5A1_UNORM_PACK16 (";
        break;
    case 7:
        settings.stream() << "VK_FORMAT_B5G5R5A1_UNORM_PACK16 (";
        break;
    case 8:
        settings.stream() << "VK_FORMAT_A1R5G5B5_UNORM_PACK16 (";
        break;
    case 9:
        settings.stream() << "VK_FORMAT_R8_UNORM (";
        break;
    case 10:
        settings.stream() << "VK_FORMAT_R8_SNORM (";
        break;
    case 11:
        settings.stream() << "VK_FORMAT_R8_USCALED (";
        break;
    case 12:
        settings.stream() << "VK_FORMAT_R8_SSCALED (";
        break;
    case 13:
        settings.stream() << "VK_FORMAT_R8_UINT (";
        break;
    case 14:
        settings.stream() << "VK_FORMAT_R8_SINT (";
        break;
    case 15:
        settings.stream() << "VK_FORMAT_R8_SRGB (";
        break;
    case 16:
        settings.stream() << "VK_FORMAT_R8G8_UNORM (";
        break;
    case 17:
        settings.stream() << "VK_FORMAT_R8G8_SNORM (";
        break;
    case 18:
        settings.stream() << "VK_FORMAT_R8G8_USCALED (";
        break;
    case 19:
        settings.stream() << "VK_FORMAT_R8G8_SSCALED (";
        break;
    case 20:
        settings.stream() << "VK_FORMAT_R8G8_UINT (";
        break;
    case 21:
        settings.stream() << "VK_FORMAT_R8G8_SINT (";
        break;
    case 22:
        settings.stream() << "VK_FORMAT_R8G8_SRGB (";
        break;
    case 23:
        settings.stream() << "VK_FORMAT_R8G8B8_UNORM (";
        break;
    case 24:
        settings.stream() << "VK_FORMAT_R8G8B8_SNORM (";
        break;
    case 25:
        settings.stream() << "VK_FORMAT_R8G8B8_USCALED (";
        break;
    case 26:
        settings.stream() << "VK_FORMAT_R8G8B8_SSCALED (";
        break;
    case 27:
        settings.stream() << "VK_FORMAT_R8G8B8_UINT (";
        break;
    case 28:
        settings.stream() << "VK_FORMAT_R8G8B8_SINT (";
        break;
    case 29:
        settings.stream() << "VK_FORMAT_R8G8B8_SRGB (";
        break;
    case 30:
        settings.stream() << "VK_FORMAT_B8G8R8_UNORM (";
        break;
    case 31:
        settings.stream() << "VK_FORMAT_B8G8R8_SNORM (";
        break;
    case 32:
        settings.stream() << "VK_FORMAT_B8G8R8_USCALED (";
        break;
    case 33:
        settings.stream() << "VK_FORMAT_B8G8R8_SSCALED (";
        break;
    case 34:
        settings.stream() << "VK_FORMAT_B8G8R8_UINT (";
        break;
    case 35:
        settings.stream() << "VK_FORMAT_B8G8R8_SINT (";
        break;
    case 36:
        settings.stream() << "VK_FORMAT_B8G8R8_SRGB (";
        break;
    case 37:
        settings.stream() << "VK_FORMAT_R8G8B8A8_UNORM (";
        break;
    case 38:
        settings.stream() << "VK_FORMAT_R8G8B8A8_SNORM (";
        break;
    case 39:
        settings.stream() << "VK_FORMAT_R8G8B8A8_USCALED (";
        break;
    case 40:
        settings.stream() << "VK_FORMAT_R8G8B8A8_SSCALED (";
        break;
    case 41:
        settings.stream() << "VK_FORMAT_R8G8B8A8_UINT (";
        break;
    case 42:
        settings.stream() << "VK_FORMAT_R8G8B8A8_SINT (";
        break;
    case 43:
        settings.stream() << "VK_FORMAT_R8G8B8A8_SRGB (";
        break;
    case 44:
        settings.stream() << "VK_FORMAT_B8G8R8A8_UNORM (";
        break;
    case 45:
        settings.stream() << "VK_FORMAT_B8G8R8A8_SNORM (";
        break;
    case 46:
        settings.stream() << "VK_FORMAT_B8G8R8A8_USCALED (";
        break;
    case 47:
        settings.stream() << "VK_FORMAT_B8G8R8A8_SSCALED (";
        break;
    case 48:
        settings.stream() << "VK_FORMAT_B8G8R8A8_UINT (";
        break;
    case 49:
        settings.stream() << "VK_FORMAT_B8G8R8A8_SINT (";
        break;
    case 50:
        settings.stream() << "VK_FORMAT_B8G8R8A8_SRGB (";
        break;
    case 51:
        settings.stream() << "VK_FORMAT_A8B8G8R8_UNORM_PACK32 (";
        break;
    case 52:
        settings.stream() << "VK_FORMAT_A8B8G8R8_SNORM_PACK32 (";
        break;
    case 53:
        settings.stream() << "VK_FORMAT_A8B8G8R8_USCALED_PACK32 (";
        break;
    case 54:
        settings.stream() << "VK_FORMAT_A8B8G8R8_SSCALED_PACK32 (";
        break;
    case 55:
        settings.stream() << "VK_FORMAT_A8B8G8R8_UINT_PACK32 (";
        break;
    case 56:
        settings.stream() << "VK_FORMAT_A8B8G8R8_SINT_PACK32 (";
        break;
    case 57:
        settings.stream() << "VK_FORMAT_A8B8G8R8_SRGB_PACK32 (";
        break;
    case 58:
        settings.stream() << "VK_FORMAT_A2R10G10B10_UNORM_PACK32 (";
        break;
    case 59:
        settings.stream() << "VK_FORMAT_A2R10G10B10_SNORM_PACK32 (";
        break;
    case 60:
        settings.stream() << "VK_FORMAT_A2R10G10B10_USCALED_PACK32 (";
        break;
    case 61:
        settings.stream() << "VK_FORMAT_A2R10G10B10_SSCALED_PACK32 (";
        break;
    case 62:
        settings.stream() << "VK_FORMAT_A2R10G10B10_UINT_PACK32 (";
        break;
    case 63:
        settings.stream() << "VK_FORMAT_A2R10G10B10_SINT_PACK32 (";
        break;
    case 64:
        settings.stream() << "VK_FORMAT_A2B10G10R10_UNORM_PACK32 (";
        break;
    case 65:
        settings.stream() << "VK_FORMAT_A2B10G10R10_SNORM_PACK32 (";
        break;
    case 66:
        settings.stream() << "VK_FORMAT_A2B10G10R10_USCALED_PACK32 (";
        break;
    case 67:
        settings.stream() << "VK_FORMAT_A2B10G10R10_SSCALED_PACK32 (";
        break;
    case 68:
        settings.stream() << "VK_FORMAT_A2B10G10R10_UINT_PACK32 (";
        break;
    case 69:
        settings.stream() << "VK_FORMAT_A2B10G10R10_SINT_PACK32 (";
        break;
    case 70:
        settings.stream() << "VK_FORMAT_R16_UNORM (";
        break;
    case 71:
        settings.stream() << "VK_FORMAT_R16_SNORM (";
        break;
    case 72:
        settings.stream() << "VK_FORMAT_R16_USCALED (";
        break;
    case 73:
        settings.stream() << "VK_FORMAT_R16_SSCALED (";
        break;
    case 74:
        settings.stream() << "VK_FORMAT_R16_UINT (";
        break;
    case 75:
        settings.stream() << "VK_FORMAT_R16_SINT (";
        break;
    case 76:
        settings.stream() << "VK_FORMAT_R16_SFLOAT (";
        break;
    case 77:
        settings.stream() << "VK_FORMAT_R16G16_UNORM (";
        break;
    case 78:
        settings.stream() << "VK_FORMAT_R16G16_SNORM (";
        break;
    case 79:
        settings.stream() << "VK_FORMAT_R16G16_USCALED (";
        break;
    case 80:
        settings.stream() << "VK_FORMAT_R16G16_SSCALED (";
        break;
    case 81:
        settings.stream() << "VK_FORMAT_R16G16_UINT (";
        break;
    case 82:
        settings.stream() << "VK_FORMAT_R16G16_SINT (";
        break;
    case 83:
        settings.stream() << "VK_FORMAT_R16G16_SFLOAT (";
        break;
    case 84:
        settings.stream() << "VK_FORMAT_R16G16B16_UNORM (";
        break;
    case 85:
        settings.stream() << "VK_FORMAT_R16G16B16_SNORM (";
        break;
    case 86:
        settings.stream() << "VK_FORMAT_R16G16B16_USCALED (";
        break;
    case 87:
        settings.stream() << "VK_FORMAT_R16G16B16_SSCALED (";
        break;
    case 88:
        settings.stream() << "VK_FORMAT_R16G16B16_UINT (";
        break;
    case 89:
        settings.stream() << "VK_FORMAT_R16G16B16_SINT (";
        break;
    case 90:
        settings.stream() << "VK_FORMAT_R16G16B16_SFLOAT (";
        break;
    case 91:
        settings.stream() << "VK_FORMAT_R16G16B16A16_UNORM (";
        break;
    case 92:
        settings.stream() << "VK_FORMAT_R16G16B16A16_SNORM (";
        break;
    case 93:
        settings.stream() << "VK_FORMAT_R16G16B16A16_USCALED (";
        break;
    case 94:
        settings.stream() << "VK_FORMAT_R16G16B16A16_SSCALED (";
        break;
    case 95:
        settings.stream() << "VK_FORMAT_R16G16B16A16_UINT (";
        break;
    case 96:
        settings.stream() << "VK_FORMAT_R16G16B16A16_SINT (";
        break;
    case 97:
        settings.stream() << "VK_FORMAT_R16G16B16A16_SFLOAT (";
        break;
    case 98:
        settings.stream() << "VK_FORMAT_R32_UINT (";
        break;
    case 99:
        settings.stream() << "VK_FORMAT_R32_SINT (";
        break;
    case 100:
        settings.stream() << "VK_FORMAT_R32_SFLOAT (";
        break;
    case 101:
        settings.stream() << "VK_FORMAT_R32G32_UINT (";
        break;
    case 102:
        settings.stream() << "VK_FORMAT_R32G32_SINT (";
        break;
    case 103:
        settings.stream() << "VK_FORMAT_R32G32_SFLOAT (";
        break;
    case 104:
        settings.stream() << "VK_FORMAT_R32G32B32_UINT (";
        break;
    case 105:
        settings.stream() << "VK_FORMAT_R32G32B32_SINT (";
        break;
    case 106:
        settings.stream() << "VK_FORMAT_R32G32B32_SFLOAT (";
        break;
    case 107:
        settings.stream() << "VK_FORMAT_R32G32B32A32_UINT (";
        break;
    case 108:
        settings.stream() << "VK_FORMAT_R32G32B32A32_SINT (";
        break;
    case 109:
        settings.stream() << "VK_FORMAT_R32G32B32A32_SFLOAT (";
        break;
    case 110:
        settings.stream() << "VK_FORMAT_R64_UINT (";
        break;
    case 111:
        settings.stream() << "VK_FORMAT_R64_SINT (";
        break;
    case 112:
        settings.stream() << "VK_FORMAT_R64_SFLOAT (";
        break;
    case 113:
        settings.stream() << "VK_FORMAT_R64G64_UINT (";
        break;
    case 114:
        settings.stream() << "VK_FORMAT_R64G64_SINT (";
        break;
    case 115:
        settings.stream() << "VK_FORMAT_R64G64_SFLOAT (";
        break;
    case 116:
        settings.stream() << "VK_FORMAT_R64G64B64_UINT (";
        break;
    case 117:
        settings.stream() << "VK_FORMAT_R64G64B64_SINT (";
        break;
    case 118:
        settings.stream() << "VK_FORMAT_R64G64B64_SFLOAT (";
        break;
    case 119:
        settings.stream() << "VK_FORMAT_R64G64B64A64_UINT (";
        break;
    case 120:
        settings.stream() << "VK_FORMAT_R64G64B64A64_SINT (";
        break;
    case 121:
        settings.stream() << "VK_FORMAT_R64G64B64A64_SFLOAT (";
        break;
    case 122:
        settings.stream() << "VK_FORMAT_B10G11R11_UFLOAT_PACK32 (";
        break;
    case 123:
        settings.stream() << "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 (";
        break;
    case 124:
        settings.stream() << "VK_FORMAT_D16_UNORM (";
        break;
    case 125:
        settings.stream() << "VK_FORMAT_X8_D24_UNORM_PACK32 (";
        break;
    case 126:
        settings.stream() << "VK_FORMAT_D32_SFLOAT (";
        break;
    case 127:
        settings.stream() << "VK_FORMAT_S8_UINT (";
        break;
    case 128:
        settings.stream() << "VK_FORMAT_D16_UNORM_S8_UINT (";
        break;
    case 129:
        settings.stream() << "VK_FORMAT_D24_UNORM_S8_UINT (";
        break;
    case 130:
        settings.stream() << "VK_FORMAT_D32_SFLOAT_S8_UINT (";
        break;
    case 131:
        settings.stream() << "VK_FORMAT_BC1_RGB_UNORM_BLOCK (";
        break;
    case 132:
        settings.stream() << "VK_FORMAT_BC1_RGB_SRGB_BLOCK (";
        break;
    case 133:
        settings.stream() << "VK_FORMAT_BC1_RGBA_UNORM_BLOCK (";
        break;
    case 134:
        settings.stream() << "VK_FORMAT_BC1_RGBA_SRGB_BLOCK (";
        break;
    case 135:
        settings.stream() << "VK_FORMAT_BC2_UNORM_BLOCK (";
        break;
    case 136:
        settings.stream() << "VK_FORMAT_BC2_SRGB_BLOCK (";
        break;
    case 137:
        settings.stream() << "VK_FORMAT_BC3_UNORM_BLOCK (";
        break;
    case 138:
        settings.stream() << "VK_FORMAT_BC3_SRGB_BLOCK (";
        break;
    case 139:
        settings.stream() << "VK_FORMAT_BC4_UNORM_BLOCK (";
        break;
    case 140:
        settings.stream() << "VK_FORMAT_BC4_SNORM_BLOCK (";
        break;
    case 141:
        settings.stream() << "VK_FORMAT_BC5_UNORM_BLOCK (";
        break;
    case 142:
        settings.stream() << "VK_FORMAT_BC5_SNORM_BLOCK (";
        break;
    case 143:
        settings.stream() << "VK_FORMAT_BC6H_UFLOAT_BLOCK (";
        break;
    case 144:
        settings.stream() << "VK_FORMAT_BC6H_SFLOAT_BLOCK (";
        break;
    case 145:
        settings.stream() << "VK_FORMAT_BC7_UNORM_BLOCK (";
        break;
    case 146:
        settings.stream() << "VK_FORMAT_BC7_SRGB_BLOCK (";
        break;
    case 147:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK (";
        break;
    case 148:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK (";
        break;
    case 149:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK (";
        break;
    case 150:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK (";
        break;
    case 151:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK (";
        break;
    case 152:
        settings.stream() << "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK (";
        break;
    case 153:
        settings.stream() << "VK_FORMAT_EAC_R11_UNORM_BLOCK (";
        break;
    case 154:
        settings.stream() << "VK_FORMAT_EAC_R11_SNORM_BLOCK (";
        break;
    case 155:
        settings.stream() << "VK_FORMAT_EAC_R11G11_UNORM_BLOCK (";
        break;
    case 156:
        settings.stream() << "VK_FORMAT_EAC_R11G11_SNORM_BLOCK (";
        break;
    case 157:
        settings.stream() << "VK_FORMAT_ASTC_4x4_UNORM_BLOCK (";
        break;
    case 158:
        settings.stream() << "VK_FORMAT_ASTC_4x4_SRGB_BLOCK (";
        break;
    case 159:
        settings.stream() << "VK_FORMAT_ASTC_5x4_UNORM_BLOCK (";
        break;
    case 160:
        settings.stream() << "VK_FORMAT_ASTC_5x4_SRGB_BLOCK (";
        break;
    case 161:
        settings.stream() << "VK_FORMAT_ASTC_5x5_UNORM_BLOCK (";
        break;
    case 162:
        settings.stream() << "VK_FORMAT_ASTC_5x5_SRGB_BLOCK (";
        break;
    case 163:
        settings.stream() << "VK_FORMAT_ASTC_6x5_UNORM_BLOCK (";
        break;
    case 164:
        settings.stream() << "VK_FORMAT_ASTC_6x5_SRGB_BLOCK (";
        break;
    case 165:
        settings.stream() << "VK_FORMAT_ASTC_6x6_UNORM_BLOCK (";
        break;
    case 166:
        settings.stream() << "VK_FORMAT_ASTC_6x6_SRGB_BLOCK (";
        break;
    case 167:
        settings.stream() << "VK_FORMAT_ASTC_8x5_UNORM_BLOCK (";
        break;
    case 168:
        settings.stream() << "VK_FORMAT_ASTC_8x5_SRGB_BLOCK (";
        break;
    case 169:
        settings.stream() << "VK_FORMAT_ASTC_8x6_UNORM_BLOCK (";
        break;
    case 170:
        settings.stream() << "VK_FORMAT_ASTC_8x6_SRGB_BLOCK (";
        break;
    case 171:
        settings.stream() << "VK_FORMAT_ASTC_8x8_UNORM_BLOCK (";
        break;
    case 172:
        settings.stream() << "VK_FORMAT_ASTC_8x8_SRGB_BLOCK (";
        break;
    case 173:
        settings.stream() << "VK_FORMAT_ASTC_10x5_UNORM_BLOCK (";
        break;
    case 174:
        settings.stream() << "VK_FORMAT_ASTC_10x5_SRGB_BLOCK (";
        break;
    case 175:
        settings.stream() << "VK_FORMAT_ASTC_10x6_UNORM_BLOCK (";
        break;
    case 176:
        settings.stream() << "VK_FORMAT_ASTC_10x6_SRGB_BLOCK (";
        break;
    case 177:
        settings.stream() << "VK_FORMAT_ASTC_10x8_UNORM_BLOCK (";
        break;
    case 178:
        settings.stream() << "VK_FORMAT_ASTC_10x8_SRGB_BLOCK (";
        break;
    case 179:
        settings.stream() << "VK_FORMAT_ASTC_10x10_UNORM_BLOCK (";
        break;
    case 180:
        settings.stream() << "VK_FORMAT_ASTC_10x10_SRGB_BLOCK (";
        break;
    case 181:
        settings.stream() << "VK_FORMAT_ASTC_12x10_UNORM_BLOCK (";
        break;
    case 182:
        settings.stream() << "VK_FORMAT_ASTC_12x10_SRGB_BLOCK (";
        break;
    case 183:
        settings.stream() << "VK_FORMAT_ASTC_12x12_UNORM_BLOCK (";
        break;
    case 184:
        settings.stream() << "VK_FORMAT_ASTC_12x12_SRGB_BLOCK (";
        break;
    case 1000156000:
        settings.stream() << "VK_FORMAT_G8B8G8R8_422_UNORM (";
        break;
    case 1000156001:
        settings.stream() << "VK_FORMAT_B8G8R8G8_422_UNORM (";
        break;
    case 1000156002:
        settings.stream() << "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM (";
        break;
    case 1000156003:
        settings.stream() << "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM (";
        break;
    case 1000156004:
        settings.stream() << "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM (";
        break;
    case 1000156005:
        settings.stream() << "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM (";
        break;
    case 1000156006:
        settings.stream() << "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM (";
        break;
    case 1000156007:
        settings.stream() << "VK_FORMAT_R10X6_UNORM_PACK16 (";
        break;
    case 1000156008:
        settings.stream() << "VK_FORMAT_R10X6G10X6_UNORM_2PACK16 (";
        break;
    case 1000156009:
        settings.stream() << "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 (";
        break;
    case 1000156010:
        settings.stream() << "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 (";
        break;
    case 1000156011:
        settings.stream() << "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 (";
        break;
    case 1000156012:
        settings.stream() << "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 (";
        break;
    case 1000156013:
        settings.stream() << "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 (";
        break;
    case 1000156014:
        settings.stream() << "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 (";
        break;
    case 1000156015:
        settings.stream() << "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 (";
        break;
    case 1000156016:
        settings.stream() << "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 (";
        break;
    case 1000156017:
        settings.stream() << "VK_FORMAT_R12X4_UNORM_PACK16 (";
        break;
    case 1000156018:
        settings.stream() << "VK_FORMAT_R12X4G12X4_UNORM_2PACK16 (";
        break;
    case 1000156019:
        settings.stream() << "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 (";
        break;
    case 1000156020:
        settings.stream() << "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 (";
        break;
    case 1000156021:
        settings.stream() << "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 (";
        break;
    case 1000156022:
        settings.stream() << "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 (";
        break;
    case 1000156023:
        settings.stream() << "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 (";
        break;
    case 1000156024:
        settings.stream() << "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 (";
        break;
    case 1000156025:
        settings.stream() << "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 (";
        break;
    case 1000156026:
        settings.stream() << "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 (";
        break;
    case 1000156027:
        settings.stream() << "VK_FORMAT_G16B16G16R16_422_UNORM (";
        break;
    case 1000156028:
        settings.stream() << "VK_FORMAT_B16G16R16G16_422_UNORM (";
        break;
    case 1000156029:
        settings.stream() << "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM (";
        break;
    case 1000156030:
        settings.stream() << "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM (";
        break;
    case 1000156031:
        settings.stream() << "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM (";
        break;
    case 1000156032:
        settings.stream() << "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM (";
        break;
    case 1000156033:
        settings.stream() << "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM (";
        break;
    case 1000330000:
        settings.stream() << "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM (";
        break;
    case 1000330001:
        settings.stream() << "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 (";
        break;
    case 1000330002:
        settings.stream() << "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 (";
        break;
    case 1000330003:
        settings.stream() << "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM (";
        break;
    case 1000340000:
        settings.stream() << "VK_FORMAT_A4R4G4B4_UNORM_PACK16 (";
        break;
    case 1000340001:
        settings.stream() << "VK_FORMAT_A4B4G4R4_UNORM_PACK16 (";
        break;
    case 1000066000:
        settings.stream() << "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK (";
        break;
    case 1000066001:
        settings.stream() << "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK (";
        break;
    case 1000066002:
        settings.stream() << "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK (";
        break;
    case 1000066003:
        settings.stream() << "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK (";
        break;
    case 1000066004:
        settings.stream() << "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK (";
        break;
    case 1000066005:
        settings.stream() << "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK (";
        break;
    case 1000066006:
        settings.stream() << "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK (";
        break;
    case 1000066007:
        settings.stream() << "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK (";
        break;
    case 1000066008:
        settings.stream() << "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK (";
        break;
    case 1000066009:
        settings.stream() << "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK (";
        break;
    case 1000066010:
        settings.stream() << "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK (";
        break;
    case 1000066011:
        settings.stream() << "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK (";
        break;
    case 1000066012:
        settings.stream() << "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK (";
        break;
    case 1000066013:
        settings.stream() << "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK (";
        break;
    case 1000470000:
        settings.stream() << "VK_FORMAT_A1B5G5R5_UNORM_PACK16 (";
        break;
    case 1000470001:
        settings.stream() << "VK_FORMAT_A8_UNORM (";
        break;
    case 1000054000:
        settings.stream() << "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG (";
        break;
    case 1000054001:
        settings.stream() << "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG (";
        break;
    case 1000054002:
        settings.stream() << "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG (";
        break;
    case 1000054003:
        settings.stream() << "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG (";
        break;
    case 1000054004:
        settings.stream() << "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG (";
        break;
    case 1000054005:
        settings.stream() << "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG (";
        break;
    case 1000054006:
        settings.stream() << "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG (";
        break;
    case 1000054007:
        settings.stream() << "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG (";
        break;
    case 1000288000:
        settings.stream() << "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT (";
        break;
    case 1000288001:
        settings.stream() << "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT (";
        break;
    case 1000288002:
        settings.stream() << "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288003:
        settings.stream() << "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT (";
        break;
    case 1000288004:
        settings.stream() << "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT (";
        break;
    case 1000288005:
        settings.stream() << "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288006:
        settings.stream() << "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT (";
        break;
    case 1000288007:
        settings.stream() << "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT (";
        break;
    case 1000288008:
        settings.stream() << "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288009:
        settings.stream() << "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT (";
        break;
    case 1000288010:
        settings.stream() << "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT (";
        break;
    case 1000288011:
        settings.stream() << "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288012:
        settings.stream() << "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT (";
        break;
    case 1000288013:
        settings.stream() << "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT (";
        break;
    case 1000288014:
        settings.stream() << "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288015:
        settings.stream() << "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT (";
        break;
    case 1000288016:
        settings.stream() << "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT (";
        break;
    case 1000288017:
        settings.stream() << "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288018:
        settings.stream() << "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT (";
        break;
    case 1000288019:
        settings.stream() << "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT (";
        break;
    case 1000288020:
        settings.stream() << "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288021:
        settings.stream() << "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT (";
        break;
    case 1000288022:
        settings.stream() << "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT (";
        break;
    case 1000288023:
        settings.stream() << "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288024:
        settings.stream() << "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT (";
        break;
    case 1000288025:
        settings.stream() << "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT (";
        break;
    case 1000288026:
        settings.stream() << "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT (";
        break;
    case 1000288027:
        settings.stream() << "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT (";
        break;
    case 1000288028:
        settings.stream() << "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT (";
        break;
    case 1000288029:
        settings.stream() << "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT (";
        break;
    case 1000464000:
        settings.stream() << "VK_FORMAT_R16G16_SFIXED5_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkImageTiling(VkImageTiling object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_IMAGE_TILING_OPTIMAL (";
        break;
    case 1:
        settings.stream() << "VK_IMAGE_TILING_LINEAR (";
        break;
    case 1000158000:
        settings.stream() << "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkImageType(VkImageType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_IMAGE_TYPE_1D (";
        break;
    case 1:
        settings.stream() << "VK_IMAGE_TYPE_2D (";
        break;
    case 2:
        settings.stream() << "VK_IMAGE_TYPE_3D (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPhysicalDeviceType(VkPhysicalDeviceType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PHYSICAL_DEVICE_TYPE_OTHER (";
        break;
    case 1:
        settings.stream() << "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU (";
        break;
    case 2:
        settings.stream() << "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU (";
        break;
    case 3:
        settings.stream() << "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU (";
        break;
    case 4:
        settings.stream() << "VK_PHYSICAL_DEVICE_TYPE_CPU (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkQueryType(VkQueryType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_QUERY_TYPE_OCCLUSION (";
        break;
    case 1:
        settings.stream() << "VK_QUERY_TYPE_PIPELINE_STATISTICS (";
        break;
    case 2:
        settings.stream() << "VK_QUERY_TYPE_TIMESTAMP (";
        break;
    case 1000023000:
        settings.stream() << "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR (";
        break;
    case 1000028004:
        settings.stream() << "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT (";
        break;
    case 1000116000:
        settings.stream() << "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR (";
        break;
    case 1000150000:
        settings.stream() << "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR (";
        break;
    case 1000150001:
        settings.stream() << "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR (";
        break;
    case 1000165000:
        settings.stream() << "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV (";
        break;
    case 1000210000:
        settings.stream() << "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL (";
        break;
    case 1000299000:
        settings.stream() << "VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR (";
        break;
    case 1000328000:
        settings.stream() << "VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT (";
        break;
    case 1000382000:
        settings.stream() << "VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT (";
        break;
    case 1000386000:
        settings.stream() << "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR (";
        break;
    case 1000386001:
        settings.stream() << "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR (";
        break;
    case 1000396000:
        settings.stream() << "VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT (";
        break;
    case 1000396001:
        settings.stream() << "VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSharingMode(VkSharingMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHARING_MODE_EXCLUSIVE (";
        break;
    case 1:
        settings.stream() << "VK_SHARING_MODE_CONCURRENT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkComponentSwizzle(VkComponentSwizzle object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COMPONENT_SWIZZLE_IDENTITY (";
        break;
    case 1:
        settings.stream() << "VK_COMPONENT_SWIZZLE_ZERO (";
        break;
    case 2:
        settings.stream() << "VK_COMPONENT_SWIZZLE_ONE (";
        break;
    case 3:
        settings.stream() << "VK_COMPONENT_SWIZZLE_R (";
        break;
    case 4:
        settings.stream() << "VK_COMPONENT_SWIZZLE_G (";
        break;
    case 5:
        settings.stream() << "VK_COMPONENT_SWIZZLE_B (";
        break;
    case 6:
        settings.stream() << "VK_COMPONENT_SWIZZLE_A (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkImageViewType(VkImageViewType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_1D (";
        break;
    case 1:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_2D (";
        break;
    case 2:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_3D (";
        break;
    case 3:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_CUBE (";
        break;
    case 4:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_1D_ARRAY (";
        break;
    case 5:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_2D_ARRAY (";
        break;
    case 6:
        settings.stream() << "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBlendFactor(VkBlendFactor object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BLEND_FACTOR_ZERO (";
        break;
    case 1:
        settings.stream() << "VK_BLEND_FACTOR_ONE (";
        break;
    case 2:
        settings.stream() << "VK_BLEND_FACTOR_SRC_COLOR (";
        break;
    case 3:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR (";
        break;
    case 4:
        settings.stream() << "VK_BLEND_FACTOR_DST_COLOR (";
        break;
    case 5:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR (";
        break;
    case 6:
        settings.stream() << "VK_BLEND_FACTOR_SRC_ALPHA (";
        break;
    case 7:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA (";
        break;
    case 8:
        settings.stream() << "VK_BLEND_FACTOR_DST_ALPHA (";
        break;
    case 9:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA (";
        break;
    case 10:
        settings.stream() << "VK_BLEND_FACTOR_CONSTANT_COLOR (";
        break;
    case 11:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR (";
        break;
    case 12:
        settings.stream() << "VK_BLEND_FACTOR_CONSTANT_ALPHA (";
        break;
    case 13:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA (";
        break;
    case 14:
        settings.stream() << "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE (";
        break;
    case 15:
        settings.stream() << "VK_BLEND_FACTOR_SRC1_COLOR (";
        break;
    case 16:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR (";
        break;
    case 17:
        settings.stream() << "VK_BLEND_FACTOR_SRC1_ALPHA (";
        break;
    case 18:
        settings.stream() << "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBlendOp(VkBlendOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BLEND_OP_ADD (";
        break;
    case 1:
        settings.stream() << "VK_BLEND_OP_SUBTRACT (";
        break;
    case 2:
        settings.stream() << "VK_BLEND_OP_REVERSE_SUBTRACT (";
        break;
    case 3:
        settings.stream() << "VK_BLEND_OP_MIN (";
        break;
    case 4:
        settings.stream() << "VK_BLEND_OP_MAX (";
        break;
    case 1000148000:
        settings.stream() << "VK_BLEND_OP_ZERO_EXT (";
        break;
    case 1000148001:
        settings.stream() << "VK_BLEND_OP_SRC_EXT (";
        break;
    case 1000148002:
        settings.stream() << "VK_BLEND_OP_DST_EXT (";
        break;
    case 1000148003:
        settings.stream() << "VK_BLEND_OP_SRC_OVER_EXT (";
        break;
    case 1000148004:
        settings.stream() << "VK_BLEND_OP_DST_OVER_EXT (";
        break;
    case 1000148005:
        settings.stream() << "VK_BLEND_OP_SRC_IN_EXT (";
        break;
    case 1000148006:
        settings.stream() << "VK_BLEND_OP_DST_IN_EXT (";
        break;
    case 1000148007:
        settings.stream() << "VK_BLEND_OP_SRC_OUT_EXT (";
        break;
    case 1000148008:
        settings.stream() << "VK_BLEND_OP_DST_OUT_EXT (";
        break;
    case 1000148009:
        settings.stream() << "VK_BLEND_OP_SRC_ATOP_EXT (";
        break;
    case 1000148010:
        settings.stream() << "VK_BLEND_OP_DST_ATOP_EXT (";
        break;
    case 1000148011:
        settings.stream() << "VK_BLEND_OP_XOR_EXT (";
        break;
    case 1000148012:
        settings.stream() << "VK_BLEND_OP_MULTIPLY_EXT (";
        break;
    case 1000148013:
        settings.stream() << "VK_BLEND_OP_SCREEN_EXT (";
        break;
    case 1000148014:
        settings.stream() << "VK_BLEND_OP_OVERLAY_EXT (";
        break;
    case 1000148015:
        settings.stream() << "VK_BLEND_OP_DARKEN_EXT (";
        break;
    case 1000148016:
        settings.stream() << "VK_BLEND_OP_LIGHTEN_EXT (";
        break;
    case 1000148017:
        settings.stream() << "VK_BLEND_OP_COLORDODGE_EXT (";
        break;
    case 1000148018:
        settings.stream() << "VK_BLEND_OP_COLORBURN_EXT (";
        break;
    case 1000148019:
        settings.stream() << "VK_BLEND_OP_HARDLIGHT_EXT (";
        break;
    case 1000148020:
        settings.stream() << "VK_BLEND_OP_SOFTLIGHT_EXT (";
        break;
    case 1000148021:
        settings.stream() << "VK_BLEND_OP_DIFFERENCE_EXT (";
        break;
    case 1000148022:
        settings.stream() << "VK_BLEND_OP_EXCLUSION_EXT (";
        break;
    case 1000148023:
        settings.stream() << "VK_BLEND_OP_INVERT_EXT (";
        break;
    case 1000148024:
        settings.stream() << "VK_BLEND_OP_INVERT_RGB_EXT (";
        break;
    case 1000148025:
        settings.stream() << "VK_BLEND_OP_LINEARDODGE_EXT (";
        break;
    case 1000148026:
        settings.stream() << "VK_BLEND_OP_LINEARBURN_EXT (";
        break;
    case 1000148027:
        settings.stream() << "VK_BLEND_OP_VIVIDLIGHT_EXT (";
        break;
    case 1000148028:
        settings.stream() << "VK_BLEND_OP_LINEARLIGHT_EXT (";
        break;
    case 1000148029:
        settings.stream() << "VK_BLEND_OP_PINLIGHT_EXT (";
        break;
    case 1000148030:
        settings.stream() << "VK_BLEND_OP_HARDMIX_EXT (";
        break;
    case 1000148031:
        settings.stream() << "VK_BLEND_OP_HSL_HUE_EXT (";
        break;
    case 1000148032:
        settings.stream() << "VK_BLEND_OP_HSL_SATURATION_EXT (";
        break;
    case 1000148033:
        settings.stream() << "VK_BLEND_OP_HSL_COLOR_EXT (";
        break;
    case 1000148034:
        settings.stream() << "VK_BLEND_OP_HSL_LUMINOSITY_EXT (";
        break;
    case 1000148035:
        settings.stream() << "VK_BLEND_OP_PLUS_EXT (";
        break;
    case 1000148036:
        settings.stream() << "VK_BLEND_OP_PLUS_CLAMPED_EXT (";
        break;
    case 1000148037:
        settings.stream() << "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT (";
        break;
    case 1000148038:
        settings.stream() << "VK_BLEND_OP_PLUS_DARKER_EXT (";
        break;
    case 1000148039:
        settings.stream() << "VK_BLEND_OP_MINUS_EXT (";
        break;
    case 1000148040:
        settings.stream() << "VK_BLEND_OP_MINUS_CLAMPED_EXT (";
        break;
    case 1000148041:
        settings.stream() << "VK_BLEND_OP_CONTRAST_EXT (";
        break;
    case 1000148042:
        settings.stream() << "VK_BLEND_OP_INVERT_OVG_EXT (";
        break;
    case 1000148043:
        settings.stream() << "VK_BLEND_OP_RED_EXT (";
        break;
    case 1000148044:
        settings.stream() << "VK_BLEND_OP_GREEN_EXT (";
        break;
    case 1000148045:
        settings.stream() << "VK_BLEND_OP_BLUE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCompareOp(VkCompareOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COMPARE_OP_NEVER (";
        break;
    case 1:
        settings.stream() << "VK_COMPARE_OP_LESS (";
        break;
    case 2:
        settings.stream() << "VK_COMPARE_OP_EQUAL (";
        break;
    case 3:
        settings.stream() << "VK_COMPARE_OP_LESS_OR_EQUAL (";
        break;
    case 4:
        settings.stream() << "VK_COMPARE_OP_GREATER (";
        break;
    case 5:
        settings.stream() << "VK_COMPARE_OP_NOT_EQUAL (";
        break;
    case 6:
        settings.stream() << "VK_COMPARE_OP_GREATER_OR_EQUAL (";
        break;
    case 7:
        settings.stream() << "VK_COMPARE_OP_ALWAYS (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDynamicState(VkDynamicState object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT (";
        break;
    case 1:
        settings.stream() << "VK_DYNAMIC_STATE_SCISSOR (";
        break;
    case 2:
        settings.stream() << "VK_DYNAMIC_STATE_LINE_WIDTH (";
        break;
    case 3:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_BIAS (";
        break;
    case 4:
        settings.stream() << "VK_DYNAMIC_STATE_BLEND_CONSTANTS (";
        break;
    case 5:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_BOUNDS (";
        break;
    case 6:
        settings.stream() << "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK (";
        break;
    case 7:
        settings.stream() << "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK (";
        break;
    case 8:
        settings.stream() << "VK_DYNAMIC_STATE_STENCIL_REFERENCE (";
        break;
    case 1000267000:
        settings.stream() << "VK_DYNAMIC_STATE_CULL_MODE (";
        break;
    case 1000267001:
        settings.stream() << "VK_DYNAMIC_STATE_FRONT_FACE (";
        break;
    case 1000267002:
        settings.stream() << "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY (";
        break;
    case 1000267003:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT (";
        break;
    case 1000267004:
        settings.stream() << "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT (";
        break;
    case 1000267005:
        settings.stream() << "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE (";
        break;
    case 1000267006:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE (";
        break;
    case 1000267007:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE (";
        break;
    case 1000267008:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP (";
        break;
    case 1000267009:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE (";
        break;
    case 1000267010:
        settings.stream() << "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE (";
        break;
    case 1000267011:
        settings.stream() << "VK_DYNAMIC_STATE_STENCIL_OP (";
        break;
    case 1000377001:
        settings.stream() << "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE (";
        break;
    case 1000377002:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE (";
        break;
    case 1000377004:
        settings.stream() << "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE (";
        break;
    case 1000259000:
        settings.stream() << "VK_DYNAMIC_STATE_LINE_STIPPLE (";
        break;
    case 1000087000:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV (";
        break;
    case 1000099000:
        settings.stream() << "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT (";
        break;
    case 1000099001:
        settings.stream() << "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT (";
        break;
    case 1000099002:
        settings.stream() << "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT (";
        break;
    case 1000143000:
        settings.stream() << "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT (";
        break;
    case 1000347000:
        settings.stream() << "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR (";
        break;
    case 1000164004:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV (";
        break;
    case 1000164006:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV (";
        break;
    case 1000205000:
        settings.stream() << "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV (";
        break;
    case 1000205001:
        settings.stream() << "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV (";
        break;
    case 1000226000:
        settings.stream() << "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR (";
        break;
    case 1000352000:
        settings.stream() << "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT (";
        break;
    case 1000377000:
        settings.stream() << "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT (";
        break;
    case 1000377003:
        settings.stream() << "VK_DYNAMIC_STATE_LOGIC_OP_EXT (";
        break;
    case 1000381000:
        settings.stream() << "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT (";
        break;
    case 1000455003:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT (";
        break;
    case 1000455004:
        settings.stream() << "VK_DYNAMIC_STATE_POLYGON_MODE_EXT (";
        break;
    case 1000455005:
        settings.stream() << "VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT (";
        break;
    case 1000455006:
        settings.stream() << "VK_DYNAMIC_STATE_SAMPLE_MASK_EXT (";
        break;
    case 1000455007:
        settings.stream() << "VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT (";
        break;
    case 1000455008:
        settings.stream() << "VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT (";
        break;
    case 1000455009:
        settings.stream() << "VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT (";
        break;
    case 1000455010:
        settings.stream() << "VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT (";
        break;
    case 1000455011:
        settings.stream() << "VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT (";
        break;
    case 1000455012:
        settings.stream() << "VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT (";
        break;
    case 1000455002:
        settings.stream() << "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT (";
        break;
    case 1000455013:
        settings.stream() << "VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT (";
        break;
    case 1000455014:
        settings.stream() << "VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT (";
        break;
    case 1000455015:
        settings.stream() << "VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT (";
        break;
    case 1000455016:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT (";
        break;
    case 1000455017:
        settings.stream() << "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT (";
        break;
    case 1000455018:
        settings.stream() << "VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT (";
        break;
    case 1000455019:
        settings.stream() << "VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT (";
        break;
    case 1000455020:
        settings.stream() << "VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT (";
        break;
    case 1000455021:
        settings.stream() << "VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT (";
        break;
    case 1000455022:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT (";
        break;
    case 1000455023:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV (";
        break;
    case 1000455024:
        settings.stream() << "VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV (";
        break;
    case 1000455025:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV (";
        break;
    case 1000455026:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV (";
        break;
    case 1000455027:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV (";
        break;
    case 1000455028:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV (";
        break;
    case 1000455029:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV (";
        break;
    case 1000455030:
        settings.stream() << "VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV (";
        break;
    case 1000455031:
        settings.stream() << "VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV (";
        break;
    case 1000455032:
        settings.stream() << "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV (";
        break;
    case 1000524000:
        settings.stream() << "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT (";
        break;
    case 1000582000:
        settings.stream() << "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFrontFace(VkFrontFace object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FRONT_FACE_COUNTER_CLOCKWISE (";
        break;
    case 1:
        settings.stream() << "VK_FRONT_FACE_CLOCKWISE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkVertexInputRate(VkVertexInputRate object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VERTEX_INPUT_RATE_VERTEX (";
        break;
    case 1:
        settings.stream() << "VK_VERTEX_INPUT_RATE_INSTANCE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPrimitiveTopology(VkPrimitiveTopology object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_POINT_LIST (";
        break;
    case 1:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_LINE_LIST (";
        break;
    case 2:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP (";
        break;
    case 3:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST (";
        break;
    case 4:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP (";
        break;
    case 5:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN (";
        break;
    case 6:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY (";
        break;
    case 7:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY (";
        break;
    case 8:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY (";
        break;
    case 9:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY (";
        break;
    case 10:
        settings.stream() << "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPolygonMode(VkPolygonMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_POLYGON_MODE_FILL (";
        break;
    case 1:
        settings.stream() << "VK_POLYGON_MODE_LINE (";
        break;
    case 2:
        settings.stream() << "VK_POLYGON_MODE_POINT (";
        break;
    case 1000153000:
        settings.stream() << "VK_POLYGON_MODE_FILL_RECTANGLE_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkStencilOp(VkStencilOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_STENCIL_OP_KEEP (";
        break;
    case 1:
        settings.stream() << "VK_STENCIL_OP_ZERO (";
        break;
    case 2:
        settings.stream() << "VK_STENCIL_OP_REPLACE (";
        break;
    case 3:
        settings.stream() << "VK_STENCIL_OP_INCREMENT_AND_CLAMP (";
        break;
    case 4:
        settings.stream() << "VK_STENCIL_OP_DECREMENT_AND_CLAMP (";
        break;
    case 5:
        settings.stream() << "VK_STENCIL_OP_INVERT (";
        break;
    case 6:
        settings.stream() << "VK_STENCIL_OP_INCREMENT_AND_WRAP (";
        break;
    case 7:
        settings.stream() << "VK_STENCIL_OP_DECREMENT_AND_WRAP (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkLogicOp(VkLogicOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_LOGIC_OP_CLEAR (";
        break;
    case 1:
        settings.stream() << "VK_LOGIC_OP_AND (";
        break;
    case 2:
        settings.stream() << "VK_LOGIC_OP_AND_REVERSE (";
        break;
    case 3:
        settings.stream() << "VK_LOGIC_OP_COPY (";
        break;
    case 4:
        settings.stream() << "VK_LOGIC_OP_AND_INVERTED (";
        break;
    case 5:
        settings.stream() << "VK_LOGIC_OP_NO_OP (";
        break;
    case 6:
        settings.stream() << "VK_LOGIC_OP_XOR (";
        break;
    case 7:
        settings.stream() << "VK_LOGIC_OP_OR (";
        break;
    case 8:
        settings.stream() << "VK_LOGIC_OP_NOR (";
        break;
    case 9:
        settings.stream() << "VK_LOGIC_OP_EQUIVALENT (";
        break;
    case 10:
        settings.stream() << "VK_LOGIC_OP_INVERT (";
        break;
    case 11:
        settings.stream() << "VK_LOGIC_OP_OR_REVERSE (";
        break;
    case 12:
        settings.stream() << "VK_LOGIC_OP_COPY_INVERTED (";
        break;
    case 13:
        settings.stream() << "VK_LOGIC_OP_OR_INVERTED (";
        break;
    case 14:
        settings.stream() << "VK_LOGIC_OP_NAND (";
        break;
    case 15:
        settings.stream() << "VK_LOGIC_OP_SET (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBorderColor(VkBorderColor object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK (";
        break;
    case 1:
        settings.stream() << "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK (";
        break;
    case 2:
        settings.stream() << "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK (";
        break;
    case 3:
        settings.stream() << "VK_BORDER_COLOR_INT_OPAQUE_BLACK (";
        break;
    case 4:
        settings.stream() << "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE (";
        break;
    case 5:
        settings.stream() << "VK_BORDER_COLOR_INT_OPAQUE_WHITE (";
        break;
    case 1000287003:
        settings.stream() << "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT (";
        break;
    case 1000287004:
        settings.stream() << "VK_BORDER_COLOR_INT_CUSTOM_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFilter(VkFilter object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FILTER_NEAREST (";
        break;
    case 1:
        settings.stream() << "VK_FILTER_LINEAR (";
        break;
    case 1000015000:
        settings.stream() << "VK_FILTER_CUBIC_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSamplerAddressMode(VkSamplerAddressMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SAMPLER_ADDRESS_MODE_REPEAT (";
        break;
    case 1:
        settings.stream() << "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT (";
        break;
    case 2:
        settings.stream() << "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE (";
        break;
    case 3:
        settings.stream() << "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER (";
        break;
    case 4:
        settings.stream() << "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSamplerMipmapMode(VkSamplerMipmapMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SAMPLER_MIPMAP_MODE_NEAREST (";
        break;
    case 1:
        settings.stream() << "VK_SAMPLER_MIPMAP_MODE_LINEAR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDescriptorType(VkDescriptorType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DESCRIPTOR_TYPE_SAMPLER (";
        break;
    case 1:
        settings.stream() << "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER (";
        break;
    case 2:
        settings.stream() << "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE (";
        break;
    case 3:
        settings.stream() << "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE (";
        break;
    case 4:
        settings.stream() << "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER (";
        break;
    case 5:
        settings.stream() << "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER (";
        break;
    case 6:
        settings.stream() << "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER (";
        break;
    case 7:
        settings.stream() << "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER (";
        break;
    case 8:
        settings.stream() << "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC (";
        break;
    case 9:
        settings.stream() << "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC (";
        break;
    case 10:
        settings.stream() << "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT (";
        break;
    case 1000138000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK (";
        break;
    case 1000150000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR (";
        break;
    case 1000165000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV (";
        break;
    case 1000440000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM (";
        break;
    case 1000440001:
        settings.stream() << "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM (";
        break;
    case 1000351000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_MUTABLE_EXT (";
        break;
    case 1000570000:
        settings.stream() << "VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAttachmentLoadOp(VkAttachmentLoadOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ATTACHMENT_LOAD_OP_LOAD (";
        break;
    case 1:
        settings.stream() << "VK_ATTACHMENT_LOAD_OP_CLEAR (";
        break;
    case 2:
        settings.stream() << "VK_ATTACHMENT_LOAD_OP_DONT_CARE (";
        break;
    case 1000400000:
        settings.stream() << "VK_ATTACHMENT_LOAD_OP_NONE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAttachmentStoreOp(VkAttachmentStoreOp object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ATTACHMENT_STORE_OP_STORE (";
        break;
    case 1:
        settings.stream() << "VK_ATTACHMENT_STORE_OP_DONT_CARE (";
        break;
    case 1000301000:
        settings.stream() << "VK_ATTACHMENT_STORE_OP_NONE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPipelineBindPoint(VkPipelineBindPoint object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PIPELINE_BIND_POINT_GRAPHICS (";
        break;
    case 1:
        settings.stream() << "VK_PIPELINE_BIND_POINT_COMPUTE (";
        break;
    case 1000134000:
        settings.stream() << "VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX (";
        break;
    case 1000165000:
        settings.stream() << "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR (";
        break;
    case 1000369003:
        settings.stream() << "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCommandBufferLevel(VkCommandBufferLevel object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COMMAND_BUFFER_LEVEL_PRIMARY (";
        break;
    case 1:
        settings.stream() << "VK_COMMAND_BUFFER_LEVEL_SECONDARY (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkIndexType(VkIndexType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_INDEX_TYPE_UINT16 (";
        break;
    case 1:
        settings.stream() << "VK_INDEX_TYPE_UINT32 (";
        break;
    case 1000265000:
        settings.stream() << "VK_INDEX_TYPE_UINT8 (";
        break;
    case 1000165000:
        settings.stream() << "VK_INDEX_TYPE_NONE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSubpassContents(VkSubpassContents object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SUBPASS_CONTENTS_INLINE (";
        break;
    case 1:
        settings.stream() << "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS (";
        break;
    case 1000451000:
        settings.stream() << "VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPointClippingBehavior(VkPointClippingBehavior object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES (";
        break;
    case 1:
        settings.stream() << "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkTessellationDomainOrigin(VkTessellationDomainOrigin object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT (";
        break;
    case 1:
        settings.stream() << "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSamplerYcbcrModelConversion(VkSamplerYcbcrModelConversion object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY (";
        break;
    case 1:
        settings.stream() << "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY (";
        break;
    case 2:
        settings.stream() << "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 (";
        break;
    case 3:
        settings.stream() << "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 (";
        break;
    case 4:
        settings.stream() << "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSamplerYcbcrRange(VkSamplerYcbcrRange object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SAMPLER_YCBCR_RANGE_ITU_FULL (";
        break;
    case 1:
        settings.stream() << "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkChromaLocation(VkChromaLocation object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CHROMA_LOCATION_COSITED_EVEN (";
        break;
    case 1:
        settings.stream() << "VK_CHROMA_LOCATION_MIDPOINT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDescriptorUpdateTemplateType(VkDescriptorUpdateTemplateType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET (";
        break;
    case 1:
        settings.stream() << "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDriverId(VkDriverId object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_DRIVER_ID_AMD_PROPRIETARY (";
        break;
    case 2:
        settings.stream() << "VK_DRIVER_ID_AMD_OPEN_SOURCE (";
        break;
    case 3:
        settings.stream() << "VK_DRIVER_ID_MESA_RADV (";
        break;
    case 4:
        settings.stream() << "VK_DRIVER_ID_NVIDIA_PROPRIETARY (";
        break;
    case 5:
        settings.stream() << "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS (";
        break;
    case 6:
        settings.stream() << "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA (";
        break;
    case 7:
        settings.stream() << "VK_DRIVER_ID_IMAGINATION_PROPRIETARY (";
        break;
    case 8:
        settings.stream() << "VK_DRIVER_ID_QUALCOMM_PROPRIETARY (";
        break;
    case 9:
        settings.stream() << "VK_DRIVER_ID_ARM_PROPRIETARY (";
        break;
    case 10:
        settings.stream() << "VK_DRIVER_ID_GOOGLE_SWIFTSHADER (";
        break;
    case 11:
        settings.stream() << "VK_DRIVER_ID_GGP_PROPRIETARY (";
        break;
    case 12:
        settings.stream() << "VK_DRIVER_ID_BROADCOM_PROPRIETARY (";
        break;
    case 13:
        settings.stream() << "VK_DRIVER_ID_MESA_LLVMPIPE (";
        break;
    case 14:
        settings.stream() << "VK_DRIVER_ID_MOLTENVK (";
        break;
    case 15:
        settings.stream() << "VK_DRIVER_ID_COREAVI_PROPRIETARY (";
        break;
    case 16:
        settings.stream() << "VK_DRIVER_ID_JUICE_PROPRIETARY (";
        break;
    case 17:
        settings.stream() << "VK_DRIVER_ID_VERISILICON_PROPRIETARY (";
        break;
    case 18:
        settings.stream() << "VK_DRIVER_ID_MESA_TURNIP (";
        break;
    case 19:
        settings.stream() << "VK_DRIVER_ID_MESA_V3DV (";
        break;
    case 20:
        settings.stream() << "VK_DRIVER_ID_MESA_PANVK (";
        break;
    case 21:
        settings.stream() << "VK_DRIVER_ID_SAMSUNG_PROPRIETARY (";
        break;
    case 22:
        settings.stream() << "VK_DRIVER_ID_MESA_VENUS (";
        break;
    case 23:
        settings.stream() << "VK_DRIVER_ID_MESA_DOZEN (";
        break;
    case 24:
        settings.stream() << "VK_DRIVER_ID_MESA_NVK (";
        break;
    case 25:
        settings.stream() << "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA (";
        break;
    case 26:
        settings.stream() << "VK_DRIVER_ID_MESA_HONEYKRISP (";
        break;
    case 27:
        settings.stream() << "VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkShaderFloatControlsIndependence(VkShaderFloatControlsIndependence object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY (";
        break;
    case 1:
        settings.stream() << "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL (";
        break;
    case 2:
        settings.stream() << "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSamplerReductionMode(VkSamplerReductionMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE (";
        break;
    case 1:
        settings.stream() << "VK_SAMPLER_REDUCTION_MODE_MIN (";
        break;
    case 2:
        settings.stream() << "VK_SAMPLER_REDUCTION_MODE_MAX (";
        break;
    case 1000521000:
        settings.stream() << "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSemaphoreType(VkSemaphoreType object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SEMAPHORE_TYPE_BINARY (";
        break;
    case 1:
        settings.stream() << "VK_SEMAPHORE_TYPE_TIMELINE (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPipelineRobustnessBufferBehavior(VkPipelineRobustnessBufferBehavior object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT (";
        break;
    case 1:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED (";
        break;
    case 2:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS (";
        break;
    case 3:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPipelineRobustnessImageBehavior(VkPipelineRobustnessImageBehavior object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT (";
        break;
    case 1:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED (";
        break;
    case 2:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS (";
        break;
    case 3:
        settings.stream() << "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkQueueGlobalPriority(VkQueueGlobalPriority object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 128:
        settings.stream() << "VK_QUEUE_GLOBAL_PRIORITY_LOW (";
        break;
    case 256:
        settings.stream() << "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM (";
        break;
    case 512:
        settings.stream() << "VK_QUEUE_GLOBAL_PRIORITY_HIGH (";
        break;
    case 1024:
        settings.stream() << "VK_QUEUE_GLOBAL_PRIORITY_REALTIME (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkLineRasterizationMode(VkLineRasterizationMode object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_LINE_RASTERIZATION_MODE_DEFAULT (";
        break;
    case 1:
        settings.stream() << "VK_LINE_RASTERIZATION_MODE_RECTANGULAR (";
        break;
    case 2:
        settings.stream() << "VK_LINE_RASTERIZATION_MODE_BRESENHAM (";
        break;
    case 3:
        settings.stream() << "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPresentModeKHR(VkPresentModeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PRESENT_MODE_IMMEDIATE_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PRESENT_MODE_MAILBOX_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PRESENT_MODE_FIFO_KHR (";
        break;
    case 3:
        settings.stream() << "VK_PRESENT_MODE_FIFO_RELAXED_KHR (";
        break;
    case 1000111000:
        settings.stream() << "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR (";
        break;
    case 1000111001:
        settings.stream() << "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR (";
        break;
    case 1000361000:
        settings.stream() << "VK_PRESENT_MODE_FIFO_LATEST_READY_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkColorSpaceKHR(VkColorSpaceKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR (";
        break;
    case 1000104001:
        settings.stream() << "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT (";
        break;
    case 1000104002:
        settings.stream() << "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT (";
        break;
    case 1000104003:
        settings.stream() << "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT (";
        break;
    case 1000104004:
        settings.stream() << "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT (";
        break;
    case 1000104005:
        settings.stream() << "VK_COLOR_SPACE_BT709_LINEAR_EXT (";
        break;
    case 1000104006:
        settings.stream() << "VK_COLOR_SPACE_BT709_NONLINEAR_EXT (";
        break;
    case 1000104007:
        settings.stream() << "VK_COLOR_SPACE_BT2020_LINEAR_EXT (";
        break;
    case 1000104008:
        settings.stream() << "VK_COLOR_SPACE_HDR10_ST2084_EXT (";
        break;
    case 1000104009:
        settings.stream() << "VK_COLOR_SPACE_DOLBYVISION_EXT (";
        break;
    case 1000104010:
        settings.stream() << "VK_COLOR_SPACE_HDR10_HLG_EXT (";
        break;
    case 1000104011:
        settings.stream() << "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT (";
        break;
    case 1000104012:
        settings.stream() << "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT (";
        break;
    case 1000104013:
        settings.stream() << "VK_COLOR_SPACE_PASS_THROUGH_EXT (";
        break;
    case 1000104014:
        settings.stream() << "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT (";
        break;
    case 1000213000:
        settings.stream() << "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT (";
        break;
    case 2:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT (";
        break;
    case 3:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT (";
        break;
    case 4:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT (";
        break;
    case 5:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT (";
        break;
    case 6:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT (";
        break;
    case 7:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT (";
        break;
    case 8:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT (";
        break;
    case 9:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT (";
        break;
    case 10:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT (";
        break;
    case 11:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT (";
        break;
    case 12:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT (";
        break;
    case 13:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT (";
        break;
    case 14:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT (";
        break;
    case 15:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT (";
        break;
    case 16:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT (";
        break;
    case 17:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT (";
        break;
    case 18:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT (";
        break;
    case 19:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT (";
        break;
    case 20:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT (";
        break;
    case 21:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT (";
        break;
    case 22:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT (";
        break;
    case 23:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT (";
        break;
    case 24:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT (";
        break;
    case 25:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT (";
        break;
    case 26:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT (";
        break;
    case 27:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT (";
        break;
    case 28:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT (";
        break;
    case 29:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT (";
        break;
    case 30:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT (";
        break;
    case 33:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT (";
        break;
    case 1000156000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT (";
        break;
    case 1000085000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT (";
        break;
    case 1000029000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT (";
        break;
    case 1000029001:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT (";
        break;
    case 1000150000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT (";
        break;
    case 1000165000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT (";
        break;
    case 1000307000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT (";
        break;
    case 1000307001:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT (";
        break;
    case 1000366000:
        settings.stream() << "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkRasterizationOrderAMD(VkRasterizationOrderAMD object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_RASTERIZATION_ORDER_STRICT_AMD (";
        break;
    case 1:
        settings.stream() << "VK_RASTERIZATION_ORDER_RELAXED_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkQueryResultStatusKHR(VkQueryResultStatusKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case -1:
        settings.stream() << "VK_QUERY_RESULT_STATUS_ERROR_KHR (";
        break;
    case 0:
        settings.stream() << "VK_QUERY_RESULT_STATUS_NOT_READY_KHR (";
        break;
    case 1:
        settings.stream() << "VK_QUERY_RESULT_STATUS_COMPLETE_KHR (";
        break;
    case -1000299000:
        settings.stream() << "VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkShaderInfoTypeAMD(VkShaderInfoTypeAMD object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHADER_INFO_TYPE_STATISTICS_AMD (";
        break;
    case 1:
        settings.stream() << "VK_SHADER_INFO_TYPE_BINARY_AMD (";
        break;
    case 2:
        settings.stream() << "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkValidationCheckEXT(VkValidationCheckEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VALIDATION_CHECK_ALL_EXT (";
        break;
    case 1:
        settings.stream() << "VK_VALIDATION_CHECK_SHADERS_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DISPLAY_POWER_STATE_OFF_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DISPLAY_POWER_STATE_SUSPEND_EXT (";
        break;
    case 2:
        settings.stream() << "VK_DISPLAY_POWER_STATE_ON_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDeviceEventTypeEXT(VkDeviceEventTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDisplayEventTypeEXT(VkDisplayEventTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkViewportCoordinateSwizzleNV(VkViewportCoordinateSwizzleNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV (";
        break;
    case 1:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV (";
        break;
    case 2:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV (";
        break;
    case 3:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV (";
        break;
    case 4:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV (";
        break;
    case 5:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV (";
        break;
    case 6:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV (";
        break;
    case 7:
        settings.stream() << "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDiscardRectangleModeEXT(VkDiscardRectangleModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkConservativeRasterizationModeEXT(VkConservativeRasterizationModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT (";
        break;
    case 1:
        settings.stream() << "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT (";
        break;
    case 2:
        settings.stream() << "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceCounterUnitKHR(VkPerformanceCounterUnitKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR (";
        break;
    case 3:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR (";
        break;
    case 4:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR (";
        break;
    case 5:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR (";
        break;
    case 6:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR (";
        break;
    case 7:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR (";
        break;
    case 8:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR (";
        break;
    case 9:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR (";
        break;
    case 10:
        settings.stream() << "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceCounterScopeKHR(VkPerformanceCounterScopeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceCounterStorageKHR(VkPerformanceCounterStorageKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR (";
        break;
    case 3:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR (";
        break;
    case 4:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR (";
        break;
    case 5:
        settings.stream() << "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBlendOverlapEXT(VkBlendOverlapEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BLEND_OVERLAP_UNCORRELATED_EXT (";
        break;
    case 1:
        settings.stream() << "VK_BLEND_OVERLAP_DISJOINT_EXT (";
        break;
    case 2:
        settings.stream() << "VK_BLEND_OVERLAP_CONJOINT_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAccelerationStructureTypeKHR(VkAccelerationStructureTypeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR (";
        break;
    case 1:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR (";
        break;
    case 2:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR (";
        break;
    case 1:
        settings.stream() << "VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkGeometryTypeKHR(VkGeometryTypeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_GEOMETRY_TYPE_TRIANGLES_KHR (";
        break;
    case 1:
        settings.stream() << "VK_GEOMETRY_TYPE_AABBS_KHR (";
        break;
    case 2:
        settings.stream() << "VK_GEOMETRY_TYPE_INSTANCES_KHR (";
        break;
    case 1000429004:
        settings.stream() << "VK_GEOMETRY_TYPE_SPHERES_NV (";
        break;
    case 1000429005:
        settings.stream() << "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAccelerationStructureBuildTypeKHR(VkAccelerationStructureBuildTypeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR (";
        break;
    case 1:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCopyAccelerationStructureModeKHR(VkCopyAccelerationStructureModeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR (";
        break;
    case 1:
        settings.stream() << "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR (";
        break;
    case 2:
        settings.stream() << "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR (";
        break;
    case 3:
        settings.stream() << "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAccelerationStructureCompatibilityKHR(VkAccelerationStructureCompatibilityKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR (";
        break;
    case 1:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCoverageModulationModeNV(VkCoverageModulationModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COVERAGE_MODULATION_MODE_NONE_NV (";
        break;
    case 1:
        settings.stream() << "VK_COVERAGE_MODULATION_MODE_RGB_NV (";
        break;
    case 2:
        settings.stream() << "VK_COVERAGE_MODULATION_MODE_ALPHA_NV (";
        break;
    case 3:
        settings.stream() << "VK_COVERAGE_MODULATION_MODE_RGBA_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkValidationCacheHeaderVersionEXT(VkValidationCacheHeaderVersionEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkShadingRatePaletteEntryNV(VkShadingRatePaletteEntryNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV (";
        break;
    case 1:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 2:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 3:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 4:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 5:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV (";
        break;
    case 6:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV (";
        break;
    case 7:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV (";
        break;
    case 8:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV (";
        break;
    case 9:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV (";
        break;
    case 10:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV (";
        break;
    case 11:
        settings.stream() << "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV (";
        break;
    case 1:
        settings.stream() << "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV (";
        break;
    case 2:
        settings.stream() << "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV (";
        break;
    case 3:
        settings.stream() << "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkRayTracingShaderGroupTypeKHR(VkRayTracingShaderGroupTypeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR (";
        break;
    case 1:
        settings.stream() << "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR (";
        break;
    case 2:
        settings.stream() << "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAccelerationStructureMemoryRequirementsTypeNV(VkAccelerationStructureMemoryRequirementsTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV (";
        break;
    case 1:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV (";
        break;
    case 2:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkTimeDomainKHR(VkTimeDomainKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_TIME_DOMAIN_DEVICE_KHR (";
        break;
    case 1:
        settings.stream() << "VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR (";
        break;
    case 2:
        settings.stream() << "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR (";
        break;
    case 3:
        settings.stream() << "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkMemoryOverallocationBehaviorAMD(VkMemoryOverallocationBehaviorAMD object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD (";
        break;
    case 1:
        settings.stream() << "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD (";
        break;
    case 2:
        settings.stream() << "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceConfigurationTypeINTEL(VkPerformanceConfigurationTypeINTEL object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkQueryPoolSamplingModeINTEL(VkQueryPoolSamplingModeINTEL object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceOverrideTypeINTEL(VkPerformanceOverrideTypeINTEL object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceParameterTypeINTEL(VkPerformanceParameterTypeINTEL object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPerformanceValueTypeINTEL(VkPerformanceValueTypeINTEL object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL (";
        break;
    case 1:
        settings.stream() << "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL (";
        break;
    case 2:
        settings.stream() << "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL (";
        break;
    case 3:
        settings.stream() << "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL (";
        break;
    case 4:
        settings.stream() << "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR (";
        break;
    case 1:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR (";
        break;
    case 3:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR (";
        break;
    case 4:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkValidationFeatureEnableEXT(VkValidationFeatureEnableEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT (";
        break;
    case 1:
        settings.stream() << "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT (";
        break;
    case 2:
        settings.stream() << "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT (";
        break;
    case 3:
        settings.stream() << "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT (";
        break;
    case 4:
        settings.stream() << "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkValidationFeatureDisableEXT(VkValidationFeatureDisableEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT (";
        break;
    case 1:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT (";
        break;
    case 2:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT (";
        break;
    case 3:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT (";
        break;
    case 4:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT (";
        break;
    case 5:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT (";
        break;
    case 6:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT (";
        break;
    case 7:
        settings.stream() << "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkComponentTypeKHR(VkComponentTypeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COMPONENT_TYPE_FLOAT16_KHR (";
        break;
    case 1:
        settings.stream() << "VK_COMPONENT_TYPE_FLOAT32_KHR (";
        break;
    case 2:
        settings.stream() << "VK_COMPONENT_TYPE_FLOAT64_KHR (";
        break;
    case 3:
        settings.stream() << "VK_COMPONENT_TYPE_SINT8_KHR (";
        break;
    case 4:
        settings.stream() << "VK_COMPONENT_TYPE_SINT16_KHR (";
        break;
    case 5:
        settings.stream() << "VK_COMPONENT_TYPE_SINT32_KHR (";
        break;
    case 6:
        settings.stream() << "VK_COMPONENT_TYPE_SINT64_KHR (";
        break;
    case 7:
        settings.stream() << "VK_COMPONENT_TYPE_UINT8_KHR (";
        break;
    case 8:
        settings.stream() << "VK_COMPONENT_TYPE_UINT16_KHR (";
        break;
    case 9:
        settings.stream() << "VK_COMPONENT_TYPE_UINT32_KHR (";
        break;
    case 10:
        settings.stream() << "VK_COMPONENT_TYPE_UINT64_KHR (";
        break;
    case 1000141000:
        settings.stream() << "VK_COMPONENT_TYPE_BFLOAT16_KHR (";
        break;
    case 1000491000:
        settings.stream() << "VK_COMPONENT_TYPE_SINT8_PACKED_NV (";
        break;
    case 1000491001:
        settings.stream() << "VK_COMPONENT_TYPE_UINT8_PACKED_NV (";
        break;
    case 1000491002:
        settings.stream() << "VK_COMPONENT_TYPE_FLOAT_E4M3_NV (";
        break;
    case 1000491003:
        settings.stream() << "VK_COMPONENT_TYPE_FLOAT_E5M2_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkScopeKHR(VkScopeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_SCOPE_DEVICE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_SCOPE_WORKGROUP_KHR (";
        break;
    case 3:
        settings.stream() << "VK_SCOPE_SUBGROUP_KHR (";
        break;
    case 5:
        settings.stream() << "VK_SCOPE_QUEUE_FAMILY_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCoverageReductionModeNV(VkCoverageReductionModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COVERAGE_REDUCTION_MODE_MERGE_NV (";
        break;
    case 1:
        settings.stream() << "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkProvokingVertexModeEXT(VkProvokingVertexModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT (";
        break;
    case 1:
        settings.stream() << "VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkFullScreenExclusiveEXT(VkFullScreenExclusiveEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT (";
        break;
    case 1:
        settings.stream() << "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT (";
        break;
    case 2:
        settings.stream() << "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT (";
        break;
    case 3:
        settings.stream() << "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR (";
        break;
    case 3:
        settings.stream() << "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV (";
        break;
    case 1:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV (";
        break;
    case 2:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV (";
        break;
    case 3:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV (";
        break;
    case 4:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV (";
        break;
    case 5:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV (";
        break;
    case 6:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV (";
        break;
    case 7:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV (";
        break;
    case 1000328000:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV (";
        break;
    case 1000428003:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV (";
        break;
    case 1000428004:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDepthBiasRepresentationEXT(VkDepthBiasRepresentationEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT (";
        break;
    case 2:
        settings.stream() << "VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDeviceMemoryReportEventTypeEXT(VkDeviceMemoryReportEventTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT (";
        break;
    case 2:
        settings.stream() << "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT (";
        break;
    case 3:
        settings.stream() << "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT (";
        break;
    case 4:
        settings.stream() << "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkVideoEncodeTuningModeKHR(VkVideoEncodeTuningModeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR (";
        break;
    case 1:
        settings.stream() << "VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR (";
        break;
    case 2:
        settings.stream() << "VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR (";
        break;
    case 3:
        settings.stream() << "VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR (";
        break;
    case 4:
        settings.stream() << "VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFragmentShadingRateTypeNV(VkFragmentShadingRateTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV (";
        break;
    case 1:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkFragmentShadingRateNV(VkFragmentShadingRateNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV (";
        break;
    case 1:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV (";
        break;
    case 4:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV (";
        break;
    case 5:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV (";
        break;
    case 6:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV (";
        break;
    case 9:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV (";
        break;
    case 10:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV (";
        break;
    case 11:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 12:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 13:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 14:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV (";
        break;
    case 15:
        settings.stream() << "VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAccelerationStructureMotionInstanceTypeNV(VkAccelerationStructureMotionInstanceTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV (";
        break;
    case 1:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV (";
        break;
    case 2:
        settings.stream() << "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDeviceFaultAddressTypeEXT(VkDeviceFaultAddressTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT (";
        break;
    case 2:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT (";
        break;
    case 3:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT (";
        break;
    case 4:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT (";
        break;
    case 5:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT (";
        break;
    case 6:
        settings.stream() << "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDeviceFaultVendorBinaryHeaderVersionEXT(VkDeviceFaultVendorBinaryHeaderVersionEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkShaderGroupShaderKHR(VkShaderGroupShaderKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHADER_GROUP_SHADER_GENERAL_KHR (";
        break;
    case 1:
        settings.stream() << "VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR (";
        break;
    case 2:
        settings.stream() << "VK_SHADER_GROUP_SHADER_ANY_HIT_KHR (";
        break;
    case 3:
        settings.stream() << "VK_SHADER_GROUP_SHADER_INTERSECTION_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDeviceAddressBindingTypeEXT(VkDeviceAddressBindingTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkMicromapTypeEXT(VkMicromapTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT (";
        break;
    case 1000397000:
        settings.stream() << "VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBuildMicromapModeEXT(VkBuildMicromapModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BUILD_MICROMAP_MODE_BUILD_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCopyMicromapModeEXT(VkCopyMicromapModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COPY_MICROMAP_MODE_CLONE_EXT (";
        break;
    case 1:
        settings.stream() << "VK_COPY_MICROMAP_MODE_SERIALIZE_EXT (";
        break;
    case 2:
        settings.stream() << "VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT (";
        break;
    case 3:
        settings.stream() << "VK_COPY_MICROMAP_MODE_COMPACT_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkOpacityMicromapFormatEXT(VkOpacityMicromapFormatEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT (";
        break;
    case 2:
        settings.stream() << "VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkOpacityMicromapSpecialIndexEXT(VkOpacityMicromapSpecialIndexEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case -1:
        settings.stream() << "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT (";
        break;
    case -2:
        settings.stream() << "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT (";
        break;
    case -3:
        settings.stream() << "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT (";
        break;
    case -4:
        settings.stream() << "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT (";
        break;
    case -5:
        settings.stream() << "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkDisplacementMicromapFormatNV(VkDisplacementMicromapFormatNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 1:
        settings.stream() << "VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV (";
        break;
    case 2:
        settings.stream() << "VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV (";
        break;
    case 3:
        settings.stream() << "VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkRayTracingLssIndexingModeNV(VkRayTracingLssIndexingModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV (";
        break;
    case 1:
        settings.stream() << "VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkRayTracingLssPrimitiveEndCapsModeNV(VkRayTracingLssPrimitiveEndCapsModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV (";
        break;
    case 1:
        settings.stream() << "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkSubpassMergeStatusEXT(VkSubpassMergeStatusEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_MERGED_EXT (";
        break;
    case 1:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT (";
        break;
    case 2:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT (";
        break;
    case 3:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT (";
        break;
    case 4:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT (";
        break;
    case 5:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT (";
        break;
    case 6:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT (";
        break;
    case 7:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT (";
        break;
    case 8:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT (";
        break;
    case 9:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT (";
        break;
    case 10:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT (";
        break;
    case 11:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT (";
        break;
    case 12:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT (";
        break;
    case 13:
        settings.stream() << "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDirectDriverLoadingModeLUNARG(VkDirectDriverLoadingModeLUNARG object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG (";
        break;
    case 1:
        settings.stream() << "VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkOpticalFlowPerformanceLevelNV(VkOpticalFlowPerformanceLevelNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV (";
        break;
    case 1:
        settings.stream() << "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV (";
        break;
    case 2:
        settings.stream() << "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV (";
        break;
    case 3:
        settings.stream() << "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkOpticalFlowSessionBindingPointNV(VkOpticalFlowSessionBindingPointNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV (";
        break;
    case 1:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV (";
        break;
    case 2:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV (";
        break;
    case 3:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV (";
        break;
    case 4:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV (";
        break;
    case 5:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV (";
        break;
    case 6:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV (";
        break;
    case 7:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV (";
        break;
    case 8:
        settings.stream() << "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAntiLagModeAMD(VkAntiLagModeAMD object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD (";
        break;
    case 1:
        settings.stream() << "VK_ANTI_LAG_MODE_ON_AMD (";
        break;
    case 2:
        settings.stream() << "VK_ANTI_LAG_MODE_OFF_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkAntiLagStageAMD(VkAntiLagStageAMD object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_ANTI_LAG_STAGE_INPUT_AMD (";
        break;
    case 1:
        settings.stream() << "VK_ANTI_LAG_STAGE_PRESENT_AMD (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_SHADER_CODE_TYPE_BINARY_EXT (";
        break;
    case 1:
        settings.stream() << "VK_SHADER_CODE_TYPE_SPIRV_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDepthClampModeEXT(VkDepthClampModeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT (";
        break;
    case 1:
        settings.stream() << "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkRayTracingInvocationReorderModeNV(VkRayTracingInvocationReorderModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV (";
        break;
    case 1:
        settings.stream() << "VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCooperativeVectorMatrixLayoutNV(VkCooperativeVectorMatrixLayoutNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV (";
        break;
    case 1:
        settings.stream() << "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV (";
        break;
    case 2:
        settings.stream() << "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV (";
        break;
    case 3:
        settings.stream() << "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkLayerSettingTypeEXT(VkLayerSettingTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_LAYER_SETTING_TYPE_BOOL32_EXT (";
        break;
    case 1:
        settings.stream() << "VK_LAYER_SETTING_TYPE_INT32_EXT (";
        break;
    case 2:
        settings.stream() << "VK_LAYER_SETTING_TYPE_INT64_EXT (";
        break;
    case 3:
        settings.stream() << "VK_LAYER_SETTING_TYPE_UINT32_EXT (";
        break;
    case 4:
        settings.stream() << "VK_LAYER_SETTING_TYPE_UINT64_EXT (";
        break;
    case 5:
        settings.stream() << "VK_LAYER_SETTING_TYPE_FLOAT32_EXT (";
        break;
    case 6:
        settings.stream() << "VK_LAYER_SETTING_TYPE_FLOAT64_EXT (";
        break;
    case 7:
        settings.stream() << "VK_LAYER_SETTING_TYPE_STRING_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkLatencyMarkerNV(VkLatencyMarkerNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_LATENCY_MARKER_SIMULATION_START_NV (";
        break;
    case 1:
        settings.stream() << "VK_LATENCY_MARKER_SIMULATION_END_NV (";
        break;
    case 2:
        settings.stream() << "VK_LATENCY_MARKER_RENDERSUBMIT_START_NV (";
        break;
    case 3:
        settings.stream() << "VK_LATENCY_MARKER_RENDERSUBMIT_END_NV (";
        break;
    case 4:
        settings.stream() << "VK_LATENCY_MARKER_PRESENT_START_NV (";
        break;
    case 5:
        settings.stream() << "VK_LATENCY_MARKER_PRESENT_END_NV (";
        break;
    case 6:
        settings.stream() << "VK_LATENCY_MARKER_INPUT_SAMPLE_NV (";
        break;
    case 7:
        settings.stream() << "VK_LATENCY_MARKER_TRIGGER_FLASH_NV (";
        break;
    case 8:
        settings.stream() << "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV (";
        break;
    case 9:
        settings.stream() << "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV (";
        break;
    case 10:
        settings.stream() << "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV (";
        break;
    case 11:
        settings.stream() << "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkOutOfBandQueueTypeNV(VkOutOfBandQueueTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV (";
        break;
    case 1:
        settings.stream() << "VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkVideoEncodeAV1PredictionModeKHR(VkVideoEncodeAV1PredictionModeKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR (";
        break;
    case 1:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR (";
        break;
    case 3:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkVideoEncodeAV1RateControlGroupKHR(VkVideoEncodeAV1RateControlGroupKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR (";
        break;
    case 1:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR (";
        break;
    case 2:
        settings.stream() << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkBlockMatchWindowCompareModeQCOM(VkBlockMatchWindowCompareModeQCOM object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM (";
        break;
    case 1:
        settings.stream() << "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkCubicFilterWeightsQCOM(VkCubicFilterWeightsQCOM object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM (";
        break;
    case 1:
        settings.stream() << "VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM (";
        break;
    case 2:
        settings.stream() << "VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM (";
        break;
    case 3:
        settings.stream() << "VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkLayeredDriverUnderlyingApiMSFT(VkLayeredDriverUnderlyingApiMSFT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT (";
        break;
    case 1:
        settings.stream() << "VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkDisplaySurfaceStereoTypeNV(VkDisplaySurfaceStereoTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV (";
        break;
    case 1:
        settings.stream() << "VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV (";
        break;
    case 2:
        settings.stream() << "VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV (";
        break;
    case 3:
        settings.stream() << "VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPhysicalDeviceLayeredApiKHR(VkPhysicalDeviceLayeredApiKHR object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR (";
        break;
    case 1:
        settings.stream() << "VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR (";
        break;
    case 2:
        settings.stream() << "VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR (";
        break;
    case 3:
        settings.stream() << "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR (";
        break;
    case 4:
        settings.stream() << "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkClusterAccelerationStructureTypeNV(VkClusterAccelerationStructureTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV (";
        break;
    case 1:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV (";
        break;
    case 2:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkClusterAccelerationStructureOpTypeNV(VkClusterAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV (";
        break;
    case 1:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV (";
        break;
    case 2:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV (";
        break;
    case 3:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV (";
        break;
    case 4:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkClusterAccelerationStructureOpModeNV(VkClusterAccelerationStructureOpModeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV (";
        break;
    case 1:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV (";
        break;
    case 2:
        settings.stream() << "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkPartitionedAccelerationStructureOpTypeNV(VkPartitionedAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV (";
        break;
    case 1:
        settings.stream() << "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV (";
        break;
    case 2:
        settings.stream() << "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT (";
        break;
    case 1:
        settings.stream() << "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}
void dump_text_VkIndirectCommandsTokenTypeEXT(VkIndirectCommandsTokenTypeEXT object, const ApiDumpSettings& settings, int indents)
{
    switch((int64_t) object)
    {
    case 0:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT (";
        break;
    case 1:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT (";
        break;
    case 2:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT (";
        break;
    case 3:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT (";
        break;
    case 4:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT (";
        break;
    case 5:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT (";
        break;
    case 6:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT (";
        break;
    case 7:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT (";
        break;
    case 8:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT (";
        break;
    case 9:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT (";
        break;
    case 1000202002:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT (";
        break;
    case 1000202003:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT (";
        break;
    case 1000328000:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT (";
        break;
    case 1000328001:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT (";
        break;
    case 1000386004:
        settings.stream() << "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT (";
        break;
    default:
        settings.stream() << "UNKNOWN (";
    }
    settings.stream() << object << ")";
}

//========================= Bitmask Implementations =========================//

void dump_text_VkAccessFlagBits(VkAccessFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDEX_READ_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_UNIFORM_READ_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_READ_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_WRITE_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_READ_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_WRITE_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_READ_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_WRITE_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_READ_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_WRITE_BIT"; is_first = false;
    }
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_NONE"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageAspectFlagBits(VkImageAspectFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_COLOR_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_DEPTH_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_STENCIL_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_METADATA_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_0_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_1_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_2_BIT"; is_first = false;
    }
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_NONE"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkFormatFeatureFlagBits(VkFormatFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_SRC_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_DST_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DISJOINT_BIT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"; is_first = false;
    }
    if(object & 536870912) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"; is_first = false;
    }
    if(object & 1073741824) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageCreateFlagBits(VkImageCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_ALIAS_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_PROTECTED_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DISJOINT_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_RESERVED_19_BIT_EXT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSampleCountFlagBits(VkSampleCountFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_1_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_2_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_4_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_8_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_16_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_32_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_64_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageUsageFlagBits(VkImageUsageFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_DST_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLED_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_STORAGE_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_HOST_TRANSFER_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_RESERVED_24_BIT_COREAVI"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_RESERVED_23_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TILE_MEMORY_QCOM"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkInstanceCreateFlagBits(VkInstanceCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_PROTECTED_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkQueueFlagBits(VkQueueFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_GRAPHICS_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_COMPUTE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_TRANSFER_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_SPARSE_BINDING_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_PROTECTED_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_DECODE_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_RESERVED_9_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_RESERVED_7_BIT_QCOM"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_RESERVED_11_BIT_ARM"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_OPTICAL_FLOW_BIT_NV"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_RESERVED_10_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDeviceQueueCreateFlagBits(VkDeviceQueueCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_RESERVED_2_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineStageFlagBits(VkPipelineStageFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFER_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_HOST_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"; is_first = false;
    }
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_NONE"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMemoryMapFlagBits(VkMemoryMapFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_MAP_PLACED_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_MEMORY_BIND_METADATA_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSparseImageFormatFlagBits(VkSparseImageFormatFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkFenceCreateFlagBits(VkFenceCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_CREATE_SIGNALED_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkEventCreateFlagBits(VkEventCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EVENT_CREATE_DEVICE_ONLY_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkQueryPipelineStatisticFlagBits(VkQueryPipelineStatisticFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkQueryResultFlagBits(VkQueryResultFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_64_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WAIT_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_PARTIAL_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkBufferCreateFlagBits(VkBufferCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_PROTECTED_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkBufferUsageFlagBits(VkBufferUsageFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_DST_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_RESERVED_28_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TILE_MEMORY_QCOM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageViewCreateFlagBits(VkImageViewCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineCacheCreateFlagBits(VkPipelineCacheCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkColorComponentFlagBits(VkColorComponentFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_R_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_G_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_B_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_A_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineCreateFlagBits(VkPipelineCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DERIVATIVE_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT"; is_first = false;
    }
    if(object & 1073741824) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"; is_first = false;
    }
    if(object & 536870912) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkShaderStageFlagBits(VkShaderStageFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_VERTEX_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_GEOMETRY_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_FRAGMENT_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_COMPUTE_BIT"; is_first = false;
    }
    if(object == 0x0000001F) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL_GRAPHICS"; is_first = false;
    }
    if(object == 0x7FFFFFFF) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_RAYGEN_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MISS_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CALLABLE_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TASK_BIT_EXT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MESH_BIT_EXT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_RESERVED_15_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCullModeFlagBits(VkCullModeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_NONE"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_BACK_BIT"; is_first = false;
    }
    if(object == 0x00000003) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_AND_BACK"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineDepthStencilStateCreateFlagBits(VkPipelineDepthStencilStateCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineColorBlendStateCreateFlagBits(VkPipelineColorBlendStateCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineLayoutCreateFlagBits(VkPipelineLayoutCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSamplerCreateFlagBits(VkSamplerCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDescriptorPoolCreateFlagBits(VkDescriptorPoolCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDescriptorSetLayoutCreateFlagBits(VkDescriptorSetLayoutCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkAttachmentDescriptionFlagBits(VkAttachmentDescriptionFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDependencyFlagBits(VkDependencyFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_BY_REGION_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_DEVICE_GROUP_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_VIEW_LOCAL_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_EXTENSION_585_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_EXTENSION_586_BIT_IMG"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkFramebufferCreateFlagBits(VkFramebufferCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkRenderPassCreateFlagBits(VkRenderPassCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_RESERVED_2_BIT_VALVE"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSubpassDescriptionFlagBits(VkSubpassDescriptionFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCommandPoolCreateFlagBits(VkCommandPoolCreateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCommandPoolResetFlagBits(VkCommandPoolResetFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCommandBufferUsageFlagBits(VkCommandBufferUsageFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkQueryControlFlagBits(VkQueryControlFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_CONTROL_PRECISE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCommandBufferResetFlagBits(VkCommandBufferResetFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkStencilFaceFlagBits(VkStencilFaceFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_BACK_BIT"; is_first = false;
    }
    if(object == 0x00000003) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_AND_BACK"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BASIC_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_VOTE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BALLOT_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_QUAD_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPeerMemoryFeatureFlagBits(VkPeerMemoryFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_EXTENSION_621_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalMemoryHandleTypeFlagBits(VkExternalMemoryHandleTypeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_590_BIT_HUAWEI"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalMemoryFeatureFlagBits(VkExternalMemoryFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalFenceHandleTypeFlagBits(VkExternalFenceHandleTypeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalFenceFeatureFlagBits(VkExternalFenceFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkFenceImportFlagBits(VkFenceImportFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_IMPORT_TEMPORARY_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSemaphoreImportFlagBits(VkSemaphoreImportFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalSemaphoreHandleTypeFlagBits(VkExternalSemaphoreHandleTypeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalSemaphoreFeatureFlagBits(VkExternalSemaphoreFeatureFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkResolveModeFlagBits(VkResolveModeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_NONE"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_AVERAGE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MIN_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MAX_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDescriptorBindingFlagBits(VkDescriptorBindingFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSemaphoreWaitFlagBits(VkSemaphoreWaitFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_WAIT_ANY_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineCreationFeedbackFlagBits(VkPipelineCreationFeedbackFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkToolPurposeFlagBits(VkToolPurposeFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_VALIDATION_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_PROFILING_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_TRACING_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkPipelineStageFlagBits2;
void dump_text_VkPipelineStageFlagBits2(VkPipelineStageFlagBits2 object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_NONE"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_HOST_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT"; is_first = false;
    }
    if(object & 4294967296) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COPY_BIT"; is_first = false;
    }
    if(object & 8589934592) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESOLVE_BIT"; is_first = false;
    }
    if(object & 17179869184) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BLIT_BIT"; is_first = false;
    }
    if(object & 34359738368) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLEAR_BIT"; is_first = false;
    }
    if(object & 68719476736) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT"; is_first = false;
    }
    if(object & 137438953472) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT"; is_first = false;
    }
    if(object & 274877906944) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 549755813888) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI"; is_first = false;
    }
    if(object & 1099511627776) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR"; is_first = false;
    }
    if(object & 1073741824) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT"; is_first = false;
    }
    if(object & 2199023255552) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI"; is_first = false;
    }
    if(object & 8796093022208) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESERVED_43_BIT_ARM"; is_first = false;
    }
    if(object & 536870912) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV"; is_first = false;
    }
    if(object & 17592186044416) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV"; is_first = false;
    }
    if(object & 4398046511104) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESERVED_42_BIT_EXT"; is_first = false;
    }
    if(object & 70368744177664) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESERVED_46_BIT_NV"; is_first = false;
    }
    if(object & 35184372088832) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESERVED_45_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkAccessFlagBits2;
void dump_text_VkAccessFlagBits2(VkAccessFlagBits2 object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_NONE"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDEX_READ_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_UNIFORM_READ_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_READ_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_WRITE_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_READ_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_WRITE_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_READ_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_WRITE_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_READ_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_WRITE_BIT"; is_first = false;
    }
    if(object & 4294967296) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT"; is_first = false;
    }
    if(object & 8589934592) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_READ_BIT"; is_first = false;
    }
    if(object & 17179869184) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT"; is_first = false;
    }
    if(object & 34359738368) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"; is_first = false;
    }
    if(object & 68719476736) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"; is_first = false;
    }
    if(object & 144115188075855872) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_57_BIT_KHR"; is_first = false;
    }
    if(object & 288230376151711744) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_58_BIT_KHR"; is_first = false;
    }
    if(object & 576460752303423488) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_59_BIT_KHR"; is_first = false;
    }
    if(object & 70368744177664) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_46_BIT_INTEL"; is_first = false;
    }
    if(object & 137438953472) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"; is_first = false;
    }
    if(object & 274877906944) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"; is_first = false;
    }
    if(object & 2251799813685248) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM"; is_first = false;
    }
    if(object & 4503599627370496) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; is_first = false;
    }
    if(object & 2199023255552) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT"; is_first = false;
    }
    if(object & 549755813888) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"; is_first = false;
    }
    if(object & 1099511627776) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR"; is_first = false;
    }
    if(object & 17592186044416) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_READ_BIT_EXT"; is_first = false;
    }
    if(object & 35184372088832) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT"; is_first = false;
    }
    if(object & 562949953421312) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_49_BIT_ARM"; is_first = false;
    }
    if(object & 1125899906842624) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_50_BIT_ARM"; is_first = false;
    }
    if(object & 4398046511104) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV"; is_first = false;
    }
    if(object & 8796093022208) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV"; is_first = false;
    }
    if(object & 140737488355328) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_47_BIT_EXT"; is_first = false;
    }
    if(object & 281474976710656) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_48_BIT_EXT"; is_first = false;
    }
    if(object & 36028797018963968) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_55_BIT_NV"; is_first = false;
    }
    if(object & 72057594037927936) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESERVED_56_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSubmitFlagBits(VkSubmitFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SUBMIT_PROTECTED_BIT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkRenderingFlagBits(VkRenderingFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_SUSPENDING_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_RESUMING_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_INLINE_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_RESERVED_5_BIT_VALVE"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkFormatFeatureFlagBits2;
void dump_text_VkFormatFeatureFlagBits2(VkFormatFeatureFlagBits2 object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_DST_BIT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DISJOINT_BIT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT"; is_first = false;
    }
    if(object & 2147483648) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"; is_first = false;
    }
    if(object & 4294967296) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"; is_first = false;
    }
    if(object & 8589934592) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"; is_first = false;
    }
    if(object & 70368744177664) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"; is_first = false;
    }
    if(object & 536870912) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"; is_first = false;
    }
    if(object & 1073741824) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 17592186044416) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_44_BIT_EXT"; is_first = false;
    }
    if(object & 35184372088832) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_45_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"; is_first = false;
    }
    if(object & 2251799813685248) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV"; is_first = false;
    }
    if(object & 274877906944) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"; is_first = false;
    }
    if(object & 17179869184) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM"; is_first = false;
    }
    if(object & 34359738368) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"; is_first = false;
    }
    if(object & 68719476736) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM"; is_first = false;
    }
    if(object & 137438953472) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM"; is_first = false;
    }
    if(object & 140737488355328) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_47_BIT_ARM"; is_first = false;
    }
    if(object & 549755813888) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_39_BIT_EXT"; is_first = false;
    }
    if(object & 8796093022208) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_43_BIT_EXT"; is_first = false;
    }
    if(object & 1099511627776) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"; is_first = false;
    }
    if(object & 2199023255552) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"; is_first = false;
    }
    if(object & 4398046511104) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"; is_first = false;
    }
    if(object & 281474976710656) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_RESERVED_48_BIT_EXT"; is_first = false;
    }
    if(object & 562949953421312) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 1125899906842624) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMemoryUnmapFlagBits(VkMemoryUnmapFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_UNMAP_RESERVE_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkPipelineCreateFlagBits2;
void dump_text_VkPipelineCreateFlagBits2(VkPipelineCreateFlagBits2 object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT"; is_first = false;
    }
    if(object & 1073741824) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT"; is_first = false;
    }
    if(object & 4294967296) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX"; is_first = false;
    }
    if(object & 68719476736) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RESERVED_36_BIT_KHR"; is_first = false;
    }
    if(object & 549755813888) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RESERVED_39_BIT_KHR"; is_first = false;
    }
    if(object & 8589934592) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV"; is_first = false;
    }
    if(object & 17179869184) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; is_first = false;
    }
    if(object & 536870912) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 137438953472) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM"; is_first = false;
    }
    if(object & 2147483648) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; is_first = false;
    }
    if(object & 274877906944) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; is_first = false;
    }
    if(object & 34359738368) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RESERVED_35_BIT_KHR"; is_first = false;
    }
    if(object & 137438953472) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM"; is_first = false;
    }
    if(object & 1099511627776) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RESERVED_40_BIT_VALVE"; is_first = false;
    }
    if(object & 2199023255552) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RESERVED_41_BIT_KHR"; is_first = false;
    }
    if(object & 4398046511104) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RESERVED_42_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkBufferUsageFlagBits2;
void dump_text_VkBufferUsageFlagBits2(VkBufferUsageFlagBits2 object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT"; is_first = false;
    }
    if(object & 33554432) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; is_first = false;
    }
    if(object & 268435456) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_RESERVED_28_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 67108864) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; is_first = false;
    }
    if(object & 16777216) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; is_first = false;
    }
    if(object & 134217728) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM"; is_first = false;
    }
    if(object & 4294967296) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_RESERVED_32_BIT_NV"; is_first = false;
    }
    if(object & 2147483648) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_HOST_IMAGE_COPY_MEMCPY"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkCompositeAlphaFlagBitsKHR(VkCompositeAlphaFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_RESERVED_4_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDeviceGroupPresentModeFlagBitsKHR(VkDeviceGroupPresentModeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDisplayPlaneAlphaFlagBitsKHR(VkDisplayPlaneAlphaFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_INFORMATION_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_WARNING_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_ERROR_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_DEBUG_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOperationFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_NONE_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoChromaSubsamplingFlagBitsKHR(VkVideoChromaSubsamplingFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoComponentBitDepthFlagBitsKHR(VkVideoComponentBitDepthFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoCapabilityFlagBitsKHR(VkVideoCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionCreateFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoSessionParametersCreateFlagBitsKHR(VkVideoSessionParametersCreateFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoDecodeCapabilityFlagBitsKHR(VkVideoDecodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoDecodeUsageFlagBitsKHR(VkVideoDecodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_DEFAULT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH264CapabilityFlagBitsKHR(VkVideoEncodeH264CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_RESERVED_10_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH264StdFlagBitsKHR(VkVideoEncodeH264StdFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH264RateControlFlagBitsKHR(VkVideoEncodeH264RateControlFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH265CapabilityFlagBitsKHR(VkVideoEncodeH265CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_RESERVED_11_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH265StdFlagBitsKHR(VkVideoEncodeH265StdFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH265CtbSizeFlagBitsKHR(VkVideoEncodeH265CtbSizeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(VkVideoEncodeH265TransformBlockSizeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeH265RateControlFlagBitsKHR(VkVideoEncodeH265RateControlFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoDecodeH264PictureLayoutFlagBitsKHR(VkVideoDecodeH264PictureLayoutFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalMemoryHandleTypeFlagBitsNV(VkExternalMemoryHandleTypeFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkExternalMemoryFeatureFlagBitsNV(VkExternalMemoryFeatureFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkConditionalRenderingFlagBitsEXT(VkConditionalRenderingFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkSurfaceCounterFlagBitsEXT(VkSurfaceCounterFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPerformanceCounterDescriptionFlagBitsKHR(VkPerformanceCounterDescriptionFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkAcquireProfilingLockFlagBitsKHR(VkAcquireProfilingLockFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDebugUtilsMessageSeverityFlagBitsEXT(VkDebugUtilsMessageSeverityFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDebugUtilsMessageTypeFlagBitsEXT(VkDebugUtilsMessageTypeFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkBuildAccelerationStructureFlagBitsKHR(VkBuildAccelerationStructureFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkGeometryFlagBitsKHR(VkGeometryFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_OPAQUE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanceFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPipelineCompilerControlFlagBitsAMD(VkPipelineCompilerControlFlagBitsAMD object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkShaderCorePropertiesFlagBitsAMD(VkShaderCorePropertiesFlagBitsAMD object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPresentScalingFlagBitsEXT(VkPresentScalingFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_STRETCH_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPresentGravityFlagBitsEXT(VkPresentGravityFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MIN_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MAX_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_CENTERED_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkIndirectStateFlagBitsNV(VkIndirectStateFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkIndirectCommandsLayoutUsageFlagBitsNV(VkIndirectCommandsLayoutUsageFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RESERVED_2_BIT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeRateControlModeFlagBitsKHR(VkVideoEncodeRateControlModeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeFeedbackFlagBitsKHR(VkVideoEncodeFeedbackFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeUsageFlagBitsKHR(VkVideoEncodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeContentFlagBitsKHR(VkVideoEncodeContentFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDeviceDiagnosticsConfigFlagBitsNV(VkDeviceDiagnosticsConfigFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkTileShadingRenderPassFlagBitsQCOM(VkTileShadingRenderPassFlagBitsQCOM object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalObjectTypeFlagBitsEXT(VkExportMetalObjectTypeFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkGraphicsPipelineLibraryFlagBitsEXT(VkGraphicsPipelineLibraryFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageCompressionFlagBitsEXT(VkImageCompressionFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DEFAULT_EXT"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DISABLED_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkImageCompressionFixedRateFlagBitsEXT(VkImageCompressionFixedRateFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT"; is_first = false;
    }
    if(object & 32768) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT"; is_first = false;
    }
    if(object & 65536) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT"; is_first = false;
    }
    if(object & 131072) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT"; is_first = false;
    }
    if(object & 262144) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT"; is_first = false;
    }
    if(object & 524288) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT"; is_first = false;
    }
    if(object & 1048576) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT"; is_first = false;
    }
    if(object & 2097152) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT"; is_first = false;
    }
    if(object & 4194304) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT"; is_first = false;
    }
    if(object & 8388608) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkDeviceAddressBindingFlagBitsEXT(VkDeviceAddressBindingFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImageConstraintsInfoFlagBitsFUCHSIA(VkImageConstraintsInfoFlagBitsFUCHSIA object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
#endif // VK_USE_PLATFORM_FUCHSIA
void dump_text_VkFrameBoundaryFlagBitsEXT(VkFrameBoundaryFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkBuildMicromapFlagBitsEXT(VkBuildMicromapFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkMicromapCreateFlagBitsEXT(VkMicromapCreateFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM;
void dump_text_VkPhysicalDeviceSchedulingControlsFlagBitsARM(VkPhysicalDeviceSchedulingControlsFlagBitsARM object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsNV;
void dump_text_VkMemoryDecompressionMethodFlagBitsNV(VkMemoryDecompressionMethodFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkOpticalFlowGridSizeFlagBitsNV(VkOpticalFlowGridSizeFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkOpticalFlowUsageFlagBitsNV(VkOpticalFlowUsageFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV"; is_first = false;
    }
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_COST_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkOpticalFlowSessionCreateFlagBitsNV(VkOpticalFlowSessionCreateFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkOpticalFlowExecuteFlagBitsNV(VkOpticalFlowExecuteFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkShaderCreateFlagBitsEXT(VkShaderCreateFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_LINK_STAGE_BIT_EXT"; is_first = false;
    }
    if(object & 1024) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_10_BIT_KHR"; is_first = false;
    }
    if(object & 2048) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_11_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT"; is_first = false;
    }
    if(object & 64) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; is_first = false;
    }
    if(object & 128) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; is_first = false;
    }
    if(object & 256) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_8_BIT_EXT"; is_first = false;
    }
    if(object & 512) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_9_BIT_EXT"; is_first = false;
    }
    if(object & 4096) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_12_BIT_EXT"; is_first = false;
    }
    if(object & 8192) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_13_BIT_EXT"; is_first = false;
    }
    if(object & 16384) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_RESERVED_14_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEncodeAV1CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_RESERVED_5_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeAV1StdFlagBitsKHR(VkVideoEncodeAV1StdFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkVideoEncodeAV1RateControlFlagBitsKHR(VkVideoEncodeAV1RateControlFlagBitsKHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(VkClusterAccelerationStructureAddressResolutionFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV"; is_first = false;
    }
    if(object & 32) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkClusterAccelerationStructureClusterFlagBitsNV(VkClusterAccelerationStructureClusterFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkClusterAccelerationStructureGeometryFlagBitsNV(VkClusterAccelerationStructureGeometryFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkClusterAccelerationStructureIndexFormatFlagBitsNV(VkClusterAccelerationStructureIndexFormatFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkPartitionedAccelerationStructureInstanceFlagBitsNV(VkPartitionedAccelerationStructureInstanceFlagBitsNV object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV"; is_first = false;
    }
    if(object & 4) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV"; is_first = false;
    }
    if(object & 8) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV"; is_first = false;
    }
    if(object & 16) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkIndirectCommandsInputModeFlagBitsEXT(VkIndirectCommandsInputModeFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
void dump_text_VkIndirectCommandsLayoutUsageFlagBitsEXT(VkIndirectCommandsLayoutUsageFlagBitsEXT object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object & 1) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"; is_first = false;
    }
    if(object & 2) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}
// 64 bit bitmasks don't have an enum of bit values.
typedef VkFlags64 VkAccessFlagBits3KHR;
void dump_text_VkAccessFlagBits3KHR(VkAccessFlagBits3KHR object, const ApiDumpSettings& settings, int indents)
{
    bool is_first = true;
    settings.stream() << object;
    if(object == 0) {
        settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_3_NONE_KHR"; is_first = false;
    }
    if(!is_first)
        settings.stream() << ")";
}

//=========================== Flag Implementations ==========================//

void dump_text_VkAccessFlags(VkAccessFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAccessFlagBits((VkAccessFlagBits) object, settings, indents);
}
void dump_text_VkImageAspectFlags(VkImageAspectFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageAspectFlagBits((VkImageAspectFlagBits) object, settings, indents);
}
void dump_text_VkFormatFeatureFlags(VkFormatFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFormatFeatureFlagBits((VkFormatFeatureFlagBits) object, settings, indents);
}
void dump_text_VkImageCreateFlags(VkImageCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageCreateFlagBits((VkImageCreateFlagBits) object, settings, indents);
}
void dump_text_VkSampleCountFlags(VkSampleCountFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSampleCountFlagBits((VkSampleCountFlagBits) object, settings, indents);
}
void dump_text_VkImageUsageFlags(VkImageUsageFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageUsageFlagBits((VkImageUsageFlagBits) object, settings, indents);
}
void dump_text_VkInstanceCreateFlags(VkInstanceCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkInstanceCreateFlagBits((VkInstanceCreateFlagBits) object, settings, indents);
}
void dump_text_VkMemoryHeapFlags(VkMemoryHeapFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryHeapFlagBits((VkMemoryHeapFlagBits) object, settings, indents);
}
void dump_text_VkMemoryPropertyFlags(VkMemoryPropertyFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryPropertyFlagBits((VkMemoryPropertyFlagBits) object, settings, indents);
}
void dump_text_VkQueueFlags(VkQueueFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkQueueFlagBits((VkQueueFlagBits) object, settings, indents);
}
void dump_text_VkDeviceQueueCreateFlags(VkDeviceQueueCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDeviceQueueCreateFlagBits((VkDeviceQueueCreateFlagBits) object, settings, indents);
}
void dump_text_VkPipelineStageFlags(VkPipelineStageFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineStageFlagBits((VkPipelineStageFlagBits) object, settings, indents);
}
void dump_text_VkMemoryMapFlags(VkMemoryMapFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryMapFlagBits((VkMemoryMapFlagBits) object, settings, indents);
}
void dump_text_VkSparseMemoryBindFlags(VkSparseMemoryBindFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSparseMemoryBindFlagBits((VkSparseMemoryBindFlagBits) object, settings, indents);
}
void dump_text_VkSparseImageFormatFlags(VkSparseImageFormatFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSparseImageFormatFlagBits((VkSparseImageFormatFlagBits) object, settings, indents);
}
void dump_text_VkFenceCreateFlags(VkFenceCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFenceCreateFlagBits((VkFenceCreateFlagBits) object, settings, indents);
}
void dump_text_VkEventCreateFlags(VkEventCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkEventCreateFlagBits((VkEventCreateFlagBits) object, settings, indents);
}
void dump_text_VkQueryPipelineStatisticFlags(VkQueryPipelineStatisticFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkQueryPipelineStatisticFlagBits((VkQueryPipelineStatisticFlagBits) object, settings, indents);
}
void dump_text_VkQueryResultFlags(VkQueryResultFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkQueryResultFlagBits((VkQueryResultFlagBits) object, settings, indents);
}
void dump_text_VkBufferCreateFlags(VkBufferCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkBufferCreateFlagBits((VkBufferCreateFlagBits) object, settings, indents);
}
void dump_text_VkBufferUsageFlags(VkBufferUsageFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkBufferUsageFlagBits((VkBufferUsageFlagBits) object, settings, indents);
}
void dump_text_VkImageViewCreateFlags(VkImageViewCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageViewCreateFlagBits((VkImageViewCreateFlagBits) object, settings, indents);
}
void dump_text_VkPipelineCacheCreateFlags(VkPipelineCacheCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineCacheCreateFlagBits((VkPipelineCacheCreateFlagBits) object, settings, indents);
}
void dump_text_VkColorComponentFlags(VkColorComponentFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkColorComponentFlagBits((VkColorComponentFlagBits) object, settings, indents);
}
void dump_text_VkPipelineCreateFlags(VkPipelineCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineCreateFlagBits((VkPipelineCreateFlagBits) object, settings, indents);
}
void dump_text_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineShaderStageCreateFlagBits((VkPipelineShaderStageCreateFlagBits) object, settings, indents);
}
void dump_text_VkCullModeFlags(VkCullModeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCullModeFlagBits((VkCullModeFlagBits) object, settings, indents);
}
void dump_text_VkPipelineDepthStencilStateCreateFlags(VkPipelineDepthStencilStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineDepthStencilStateCreateFlagBits((VkPipelineDepthStencilStateCreateFlagBits) object, settings, indents);
}
void dump_text_VkPipelineColorBlendStateCreateFlags(VkPipelineColorBlendStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineColorBlendStateCreateFlagBits((VkPipelineColorBlendStateCreateFlagBits) object, settings, indents);
}
void dump_text_VkPipelineLayoutCreateFlags(VkPipelineLayoutCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineLayoutCreateFlagBits((VkPipelineLayoutCreateFlagBits) object, settings, indents);
}
void dump_text_VkShaderStageFlags(VkShaderStageFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkShaderStageFlagBits((VkShaderStageFlagBits) object, settings, indents);
}
void dump_text_VkSamplerCreateFlags(VkSamplerCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSamplerCreateFlagBits((VkSamplerCreateFlagBits) object, settings, indents);
}
void dump_text_VkDescriptorPoolCreateFlags(VkDescriptorPoolCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDescriptorPoolCreateFlagBits((VkDescriptorPoolCreateFlagBits) object, settings, indents);
}
void dump_text_VkDescriptorSetLayoutCreateFlags(VkDescriptorSetLayoutCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDescriptorSetLayoutCreateFlagBits((VkDescriptorSetLayoutCreateFlagBits) object, settings, indents);
}
void dump_text_VkAttachmentDescriptionFlags(VkAttachmentDescriptionFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAttachmentDescriptionFlagBits((VkAttachmentDescriptionFlagBits) object, settings, indents);
}
void dump_text_VkDependencyFlags(VkDependencyFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDependencyFlagBits((VkDependencyFlagBits) object, settings, indents);
}
void dump_text_VkFramebufferCreateFlags(VkFramebufferCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFramebufferCreateFlagBits((VkFramebufferCreateFlagBits) object, settings, indents);
}
void dump_text_VkRenderPassCreateFlags(VkRenderPassCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkRenderPassCreateFlagBits((VkRenderPassCreateFlagBits) object, settings, indents);
}
void dump_text_VkSubpassDescriptionFlags(VkSubpassDescriptionFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSubpassDescriptionFlagBits((VkSubpassDescriptionFlagBits) object, settings, indents);
}
void dump_text_VkCommandPoolCreateFlags(VkCommandPoolCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCommandPoolCreateFlagBits((VkCommandPoolCreateFlagBits) object, settings, indents);
}
void dump_text_VkCommandPoolResetFlags(VkCommandPoolResetFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCommandPoolResetFlagBits((VkCommandPoolResetFlagBits) object, settings, indents);
}
void dump_text_VkCommandBufferUsageFlags(VkCommandBufferUsageFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCommandBufferUsageFlagBits((VkCommandBufferUsageFlagBits) object, settings, indents);
}
void dump_text_VkQueryControlFlags(VkQueryControlFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkQueryControlFlagBits((VkQueryControlFlagBits) object, settings, indents);
}
void dump_text_VkCommandBufferResetFlags(VkCommandBufferResetFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCommandBufferResetFlagBits((VkCommandBufferResetFlagBits) object, settings, indents);
}
void dump_text_VkStencilFaceFlags(VkStencilFaceFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkStencilFaceFlagBits((VkStencilFaceFlagBits) object, settings, indents);
}
void dump_text_VkSubgroupFeatureFlags(VkSubgroupFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSubgroupFeatureFlagBits((VkSubgroupFeatureFlagBits) object, settings, indents);
}
void dump_text_VkPeerMemoryFeatureFlags(VkPeerMemoryFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPeerMemoryFeatureFlagBits((VkPeerMemoryFeatureFlagBits) object, settings, indents);
}
void dump_text_VkMemoryAllocateFlags(VkMemoryAllocateFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryAllocateFlagBits((VkMemoryAllocateFlagBits) object, settings, indents);
}
void dump_text_VkExternalMemoryHandleTypeFlags(VkExternalMemoryHandleTypeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalMemoryHandleTypeFlagBits((VkExternalMemoryHandleTypeFlagBits) object, settings, indents);
}
void dump_text_VkExternalMemoryFeatureFlags(VkExternalMemoryFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalMemoryFeatureFlagBits((VkExternalMemoryFeatureFlagBits) object, settings, indents);
}
void dump_text_VkExternalFenceHandleTypeFlags(VkExternalFenceHandleTypeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalFenceHandleTypeFlagBits((VkExternalFenceHandleTypeFlagBits) object, settings, indents);
}
void dump_text_VkExternalFenceFeatureFlags(VkExternalFenceFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalFenceFeatureFlagBits((VkExternalFenceFeatureFlagBits) object, settings, indents);
}
void dump_text_VkFenceImportFlags(VkFenceImportFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFenceImportFlagBits((VkFenceImportFlagBits) object, settings, indents);
}
void dump_text_VkSemaphoreImportFlags(VkSemaphoreImportFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSemaphoreImportFlagBits((VkSemaphoreImportFlagBits) object, settings, indents);
}
void dump_text_VkExternalSemaphoreHandleTypeFlags(VkExternalSemaphoreHandleTypeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalSemaphoreHandleTypeFlagBits((VkExternalSemaphoreHandleTypeFlagBits) object, settings, indents);
}
void dump_text_VkExternalSemaphoreFeatureFlags(VkExternalSemaphoreFeatureFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalSemaphoreFeatureFlagBits((VkExternalSemaphoreFeatureFlagBits) object, settings, indents);
}
void dump_text_VkResolveModeFlags(VkResolveModeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkResolveModeFlagBits((VkResolveModeFlagBits) object, settings, indents);
}
void dump_text_VkDescriptorBindingFlags(VkDescriptorBindingFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDescriptorBindingFlagBits((VkDescriptorBindingFlagBits) object, settings, indents);
}
void dump_text_VkSemaphoreWaitFlags(VkSemaphoreWaitFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSemaphoreWaitFlagBits((VkSemaphoreWaitFlagBits) object, settings, indents);
}
void dump_text_VkPipelineCreationFeedbackFlags(VkPipelineCreationFeedbackFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineCreationFeedbackFlagBits((VkPipelineCreationFeedbackFlagBits) object, settings, indents);
}
void dump_text_VkToolPurposeFlags(VkToolPurposeFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkToolPurposeFlagBits((VkToolPurposeFlagBits) object, settings, indents);
}
void dump_text_VkPipelineStageFlags2(VkPipelineStageFlags2 object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineStageFlagBits2((VkPipelineStageFlagBits2) object, settings, indents);
}
void dump_text_VkAccessFlags2(VkAccessFlags2 object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAccessFlagBits2((VkAccessFlagBits2) object, settings, indents);
}
void dump_text_VkSubmitFlags(VkSubmitFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSubmitFlagBits((VkSubmitFlagBits) object, settings, indents);
}
void dump_text_VkRenderingFlags(VkRenderingFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkRenderingFlagBits((VkRenderingFlagBits) object, settings, indents);
}
void dump_text_VkFormatFeatureFlags2(VkFormatFeatureFlags2 object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFormatFeatureFlagBits2((VkFormatFeatureFlagBits2) object, settings, indents);
}
void dump_text_VkMemoryUnmapFlags(VkMemoryUnmapFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryUnmapFlagBits((VkMemoryUnmapFlagBits) object, settings, indents);
}
void dump_text_VkPipelineCreateFlags2(VkPipelineCreateFlags2 object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineCreateFlagBits2((VkPipelineCreateFlagBits2) object, settings, indents);
}
void dump_text_VkBufferUsageFlags2(VkBufferUsageFlags2 object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkBufferUsageFlagBits2((VkBufferUsageFlagBits2) object, settings, indents);
}
void dump_text_VkHostImageCopyFlags(VkHostImageCopyFlags object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkHostImageCopyFlagBits((VkHostImageCopyFlagBits) object, settings, indents);
}
void dump_text_VkCompositeAlphaFlagsKHR(VkCompositeAlphaFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkCompositeAlphaFlagBitsKHR((VkCompositeAlphaFlagBitsKHR) object, settings, indents);
}
void dump_text_VkSurfaceTransformFlagsKHR(VkSurfaceTransformFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSurfaceTransformFlagBitsKHR((VkSurfaceTransformFlagBitsKHR) object, settings, indents);
}
void dump_text_VkSwapchainCreateFlagsKHR(VkSwapchainCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSwapchainCreateFlagBitsKHR((VkSwapchainCreateFlagBitsKHR) object, settings, indents);
}
void dump_text_VkDeviceGroupPresentModeFlagsKHR(VkDeviceGroupPresentModeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDeviceGroupPresentModeFlagBitsKHR((VkDeviceGroupPresentModeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkDisplayPlaneAlphaFlagsKHR(VkDisplayPlaneAlphaFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDisplayPlaneAlphaFlagBitsKHR((VkDisplayPlaneAlphaFlagBitsKHR) object, settings, indents);
}
void dump_text_VkDebugReportFlagsEXT(VkDebugReportFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDebugReportFlagBitsEXT((VkDebugReportFlagBitsEXT) object, settings, indents);
}
void dump_text_VkVideoCodecOperationFlagsKHR(VkVideoCodecOperationFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoCodecOperationFlagBitsKHR((VkVideoCodecOperationFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoChromaSubsamplingFlagsKHR(VkVideoChromaSubsamplingFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoChromaSubsamplingFlagBitsKHR((VkVideoChromaSubsamplingFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoComponentBitDepthFlagsKHR(VkVideoComponentBitDepthFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoComponentBitDepthFlagBitsKHR((VkVideoComponentBitDepthFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoCapabilityFlagsKHR(VkVideoCapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoCapabilityFlagBitsKHR((VkVideoCapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoSessionCreateFlagsKHR(VkVideoSessionCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoSessionCreateFlagBitsKHR((VkVideoSessionCreateFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoSessionParametersCreateFlagsKHR(VkVideoSessionParametersCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoSessionParametersCreateFlagBitsKHR((VkVideoSessionParametersCreateFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoCodingControlFlagsKHR(VkVideoCodingControlFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoCodingControlFlagBitsKHR((VkVideoCodingControlFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoDecodeCapabilityFlagsKHR(VkVideoDecodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoDecodeCapabilityFlagBitsKHR((VkVideoDecodeCapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoDecodeUsageFlagsKHR(VkVideoDecodeUsageFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoDecodeUsageFlagBitsKHR((VkVideoDecodeUsageFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH264CapabilityFlagsKHR(VkVideoEncodeH264CapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH264CapabilityFlagBitsKHR((VkVideoEncodeH264CapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH264StdFlagsKHR(VkVideoEncodeH264StdFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH264StdFlagBitsKHR((VkVideoEncodeH264StdFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH264RateControlFlagsKHR(VkVideoEncodeH264RateControlFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH264RateControlFlagBitsKHR((VkVideoEncodeH264RateControlFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH265CapabilityFlagsKHR(VkVideoEncodeH265CapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH265CapabilityFlagBitsKHR((VkVideoEncodeH265CapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH265StdFlagsKHR(VkVideoEncodeH265StdFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH265StdFlagBitsKHR((VkVideoEncodeH265StdFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH265CtbSizeFlagsKHR(VkVideoEncodeH265CtbSizeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH265CtbSizeFlagBitsKHR((VkVideoEncodeH265CtbSizeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH265TransformBlockSizeFlagsKHR(VkVideoEncodeH265TransformBlockSizeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR((VkVideoEncodeH265TransformBlockSizeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeH265RateControlFlagsKHR(VkVideoEncodeH265RateControlFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeH265RateControlFlagBitsKHR((VkVideoEncodeH265RateControlFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoDecodeH264PictureLayoutFlagsKHR(VkVideoDecodeH264PictureLayoutFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoDecodeH264PictureLayoutFlagBitsKHR((VkVideoDecodeH264PictureLayoutFlagBitsKHR) object, settings, indents);
}
void dump_text_VkExternalMemoryHandleTypeFlagsNV(VkExternalMemoryHandleTypeFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalMemoryHandleTypeFlagBitsNV((VkExternalMemoryHandleTypeFlagBitsNV) object, settings, indents);
}
void dump_text_VkExternalMemoryFeatureFlagsNV(VkExternalMemoryFeatureFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExternalMemoryFeatureFlagBitsNV((VkExternalMemoryFeatureFlagBitsNV) object, settings, indents);
}
void dump_text_VkConditionalRenderingFlagsEXT(VkConditionalRenderingFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkConditionalRenderingFlagBitsEXT((VkConditionalRenderingFlagBitsEXT) object, settings, indents);
}
void dump_text_VkSurfaceCounterFlagsEXT(VkSurfaceCounterFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkSurfaceCounterFlagBitsEXT((VkSurfaceCounterFlagBitsEXT) object, settings, indents);
}
void dump_text_VkPerformanceCounterDescriptionFlagsKHR(VkPerformanceCounterDescriptionFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPerformanceCounterDescriptionFlagBitsKHR((VkPerformanceCounterDescriptionFlagBitsKHR) object, settings, indents);
}
void dump_text_VkAcquireProfilingLockFlagsKHR(VkAcquireProfilingLockFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAcquireProfilingLockFlagBitsKHR((VkAcquireProfilingLockFlagBitsKHR) object, settings, indents);
}
void dump_text_VkDebugUtilsMessageTypeFlagsEXT(VkDebugUtilsMessageTypeFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDebugUtilsMessageTypeFlagBitsEXT((VkDebugUtilsMessageTypeFlagBitsEXT) object, settings, indents);
}
void dump_text_VkDebugUtilsMessageSeverityFlagsEXT(VkDebugUtilsMessageSeverityFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDebugUtilsMessageSeverityFlagBitsEXT((VkDebugUtilsMessageSeverityFlagBitsEXT) object, settings, indents);
}
void dump_text_VkBuildAccelerationStructureFlagsKHR(VkBuildAccelerationStructureFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkBuildAccelerationStructureFlagBitsKHR((VkBuildAccelerationStructureFlagBitsKHR) object, settings, indents);
}
void dump_text_VkGeometryFlagsKHR(VkGeometryFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkGeometryFlagBitsKHR((VkGeometryFlagBitsKHR) object, settings, indents);
}
void dump_text_VkGeometryInstanceFlagsKHR(VkGeometryInstanceFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkGeometryInstanceFlagBitsKHR((VkGeometryInstanceFlagBitsKHR) object, settings, indents);
}
void dump_text_VkAccelerationStructureCreateFlagsKHR(VkAccelerationStructureCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAccelerationStructureCreateFlagBitsKHR((VkAccelerationStructureCreateFlagBitsKHR) object, settings, indents);
}
void dump_text_VkPipelineCompilerControlFlagsAMD(VkPipelineCompilerControlFlagsAMD object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPipelineCompilerControlFlagBitsAMD((VkPipelineCompilerControlFlagBitsAMD) object, settings, indents);
}
void dump_text_VkShaderCorePropertiesFlagsAMD(VkShaderCorePropertiesFlagsAMD object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkShaderCorePropertiesFlagBitsAMD((VkShaderCorePropertiesFlagBitsAMD) object, settings, indents);
}
void dump_text_VkPresentScalingFlagsEXT(VkPresentScalingFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPresentScalingFlagBitsEXT((VkPresentScalingFlagBitsEXT) object, settings, indents);
}
void dump_text_VkPresentGravityFlagsEXT(VkPresentGravityFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPresentGravityFlagBitsEXT((VkPresentGravityFlagBitsEXT) object, settings, indents);
}
void dump_text_VkIndirectStateFlagsNV(VkIndirectStateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkIndirectStateFlagBitsNV((VkIndirectStateFlagBitsNV) object, settings, indents);
}
void dump_text_VkIndirectCommandsLayoutUsageFlagsNV(VkIndirectCommandsLayoutUsageFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkIndirectCommandsLayoutUsageFlagBitsNV((VkIndirectCommandsLayoutUsageFlagBitsNV) object, settings, indents);
}
void dump_text_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeFlagBitsKHR((VkVideoEncodeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeCapabilityFlagsKHR(VkVideoEncodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeCapabilityFlagBitsKHR((VkVideoEncodeCapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeRateControlModeFlagsKHR(VkVideoEncodeRateControlModeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeRateControlModeFlagBitsKHR((VkVideoEncodeRateControlModeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeFeedbackFlagsKHR(VkVideoEncodeFeedbackFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeFeedbackFlagBitsKHR((VkVideoEncodeFeedbackFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeUsageFlagsKHR(VkVideoEncodeUsageFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeUsageFlagBitsKHR((VkVideoEncodeUsageFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeContentFlagsKHR(VkVideoEncodeContentFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeContentFlagBitsKHR((VkVideoEncodeContentFlagBitsKHR) object, settings, indents);
}
void dump_text_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagnosticsConfigFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDeviceDiagnosticsConfigFlagBitsNV((VkDeviceDiagnosticsConfigFlagBitsNV) object, settings, indents);
}
void dump_text_VkTileShadingRenderPassFlagsQCOM(VkTileShadingRenderPassFlagsQCOM object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkTileShadingRenderPassFlagBitsQCOM((VkTileShadingRenderPassFlagBitsQCOM) object, settings, indents);
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalObjectTypeFlagsEXT(VkExportMetalObjectTypeFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkExportMetalObjectTypeFlagBitsEXT((VkExportMetalObjectTypeFlagBitsEXT) object, settings, indents);
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkGraphicsPipelineLibraryFlagsEXT(VkGraphicsPipelineLibraryFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkGraphicsPipelineLibraryFlagBitsEXT((VkGraphicsPipelineLibraryFlagBitsEXT) object, settings, indents);
}
void dump_text_VkImageCompressionFlagsEXT(VkImageCompressionFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageCompressionFlagBitsEXT((VkImageCompressionFlagBitsEXT) object, settings, indents);
}
void dump_text_VkImageCompressionFixedRateFlagsEXT(VkImageCompressionFixedRateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageCompressionFixedRateFlagBitsEXT((VkImageCompressionFixedRateFlagBitsEXT) object, settings, indents);
}
void dump_text_VkDeviceAddressBindingFlagsEXT(VkDeviceAddressBindingFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkDeviceAddressBindingFlagBitsEXT((VkDeviceAddressBindingFlagBitsEXT) object, settings, indents);
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImageConstraintsInfoFlagsFUCHSIA(VkImageConstraintsInfoFlagsFUCHSIA object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkImageConstraintsInfoFlagBitsFUCHSIA((VkImageConstraintsInfoFlagBitsFUCHSIA) object, settings, indents);
}
#endif // VK_USE_PLATFORM_FUCHSIA
void dump_text_VkFrameBoundaryFlagsEXT(VkFrameBoundaryFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkFrameBoundaryFlagBitsEXT((VkFrameBoundaryFlagBitsEXT) object, settings, indents);
}
void dump_text_VkBuildMicromapFlagsEXT(VkBuildMicromapFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkBuildMicromapFlagBitsEXT((VkBuildMicromapFlagBitsEXT) object, settings, indents);
}
void dump_text_VkMicromapCreateFlagsEXT(VkMicromapCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMicromapCreateFlagBitsEXT((VkMicromapCreateFlagBitsEXT) object, settings, indents);
}
void dump_text_VkPhysicalDeviceSchedulingControlsFlagsARM(VkPhysicalDeviceSchedulingControlsFlagsARM object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPhysicalDeviceSchedulingControlsFlagBitsARM((VkPhysicalDeviceSchedulingControlsFlagBitsARM) object, settings, indents);
}
void dump_text_VkMemoryDecompressionMethodFlagsNV(VkMemoryDecompressionMethodFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkMemoryDecompressionMethodFlagBitsNV((VkMemoryDecompressionMethodFlagBitsNV) object, settings, indents);
}
void dump_text_VkOpticalFlowGridSizeFlagsNV(VkOpticalFlowGridSizeFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkOpticalFlowGridSizeFlagBitsNV((VkOpticalFlowGridSizeFlagBitsNV) object, settings, indents);
}
void dump_text_VkOpticalFlowUsageFlagsNV(VkOpticalFlowUsageFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkOpticalFlowUsageFlagBitsNV((VkOpticalFlowUsageFlagBitsNV) object, settings, indents);
}
void dump_text_VkOpticalFlowSessionCreateFlagsNV(VkOpticalFlowSessionCreateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkOpticalFlowSessionCreateFlagBitsNV((VkOpticalFlowSessionCreateFlagBitsNV) object, settings, indents);
}
void dump_text_VkOpticalFlowExecuteFlagsNV(VkOpticalFlowExecuteFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkOpticalFlowExecuteFlagBitsNV((VkOpticalFlowExecuteFlagBitsNV) object, settings, indents);
}
void dump_text_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkShaderCreateFlagBitsEXT((VkShaderCreateFlagBitsEXT) object, settings, indents);
}
void dump_text_VkVideoEncodeAV1CapabilityFlagsKHR(VkVideoEncodeAV1CapabilityFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeAV1CapabilityFlagBitsKHR((VkVideoEncodeAV1CapabilityFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeAV1StdFlagsKHR(VkVideoEncodeAV1StdFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeAV1StdFlagBitsKHR((VkVideoEncodeAV1StdFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeAV1SuperblockSizeFlagsKHR(VkVideoEncodeAV1SuperblockSizeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR((VkVideoEncodeAV1SuperblockSizeFlagBitsKHR) object, settings, indents);
}
void dump_text_VkVideoEncodeAV1RateControlFlagsKHR(VkVideoEncodeAV1RateControlFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkVideoEncodeAV1RateControlFlagBitsKHR((VkVideoEncodeAV1RateControlFlagBitsKHR) object, settings, indents);
}
void dump_text_VkClusterAccelerationStructureAddressResolutionFlagsNV(VkClusterAccelerationStructureAddressResolutionFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkClusterAccelerationStructureAddressResolutionFlagBitsNV((VkClusterAccelerationStructureAddressResolutionFlagBitsNV) object, settings, indents);
}
void dump_text_VkClusterAccelerationStructureClusterFlagsNV(VkClusterAccelerationStructureClusterFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkClusterAccelerationStructureClusterFlagBitsNV((VkClusterAccelerationStructureClusterFlagBitsNV) object, settings, indents);
}
void dump_text_VkClusterAccelerationStructureGeometryFlagsNV(VkClusterAccelerationStructureGeometryFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkClusterAccelerationStructureGeometryFlagBitsNV((VkClusterAccelerationStructureGeometryFlagBitsNV) object, settings, indents);
}
void dump_text_VkClusterAccelerationStructureIndexFormatFlagsNV(VkClusterAccelerationStructureIndexFormatFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkClusterAccelerationStructureIndexFormatFlagBitsNV((VkClusterAccelerationStructureIndexFormatFlagBitsNV) object, settings, indents);
}
void dump_text_VkPartitionedAccelerationStructureInstanceFlagsNV(VkPartitionedAccelerationStructureInstanceFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkPartitionedAccelerationStructureInstanceFlagBitsNV((VkPartitionedAccelerationStructureInstanceFlagBitsNV) object, settings, indents);
}
void dump_text_VkIndirectCommandsInputModeFlagsEXT(VkIndirectCommandsInputModeFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkIndirectCommandsInputModeFlagBitsEXT((VkIndirectCommandsInputModeFlagBitsEXT) object, settings, indents);
}
void dump_text_VkIndirectCommandsLayoutUsageFlagsEXT(VkIndirectCommandsLayoutUsageFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkIndirectCommandsLayoutUsageFlagBitsEXT((VkIndirectCommandsLayoutUsageFlagBitsEXT) object, settings, indents);
}
void dump_text_VkAccessFlags3KHR(VkAccessFlags3KHR object, const ApiDumpSettings& settings, int indents)
{
    dump_text_VkAccessFlagBits3KHR((VkAccessFlagBits3KHR) object, settings, indents);
}


void dump_text_VkDeviceCreateFlags(VkDeviceCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkSemaphoreCreateFlags(VkSemaphoreCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkBufferViewCreateFlags(VkBufferViewCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkShaderModuleCreateFlags(VkShaderModuleCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineVertexInputStateCreateFlags(VkPipelineVertexInputStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineInputAssemblyStateCreateFlags(VkPipelineInputAssemblyStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineTessellationStateCreateFlags(VkPipelineTessellationStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineViewportStateCreateFlags(VkPipelineViewportStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineRasterizationStateCreateFlags(VkPipelineRasterizationStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineMultisampleStateCreateFlags(VkPipelineMultisampleStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineDynamicStateCreateFlags(VkPipelineDynamicStateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDescriptorPoolResetFlags(VkDescriptorPoolResetFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkCommandPoolTrimFlags(VkCommandPoolTrimFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDescriptorUpdateTemplateCreateFlags(VkDescriptorUpdateTemplateCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPrivateDataSlotCreateFlags(VkPrivateDataSlotCreateFlags object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDisplayModeCreateFlagsKHR(VkDisplayModeCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDisplaySurfaceCreateFlagsKHR(VkDisplaySurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_VkXlibSurfaceCreateFlagsKHR(VkXlibSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_VkXcbSurfaceCreateFlagsKHR(VkXcbSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_VkWaylandSurfaceCreateFlagsKHR(VkWaylandSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidSurfaceCreateFlagsKHR(VkAndroidSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkWin32SurfaceCreateFlagsKHR(VkWin32SurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkVideoBeginCodingFlagsKHR(VkVideoBeginCodingFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkVideoEndCodingFlagsKHR(VkVideoEndCodingFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkVideoDecodeFlagsKHR(VkVideoDecodeFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineRasterizationStateStreamCreateFlagsEXT(VkPipelineRasterizationStateStreamCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_VkStreamDescriptorSurfaceCreateFlagsGGP(VkStreamDescriptorSurfaceCreateFlagsGGP object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_GGP
#if defined(VK_USE_PLATFORM_VI_NN)
void dump_text_VkViSurfaceCreateFlagsNN(VkViSurfaceCreateFlagsNN object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_VI_NN
void dump_text_VkPipelineViewportSwizzleStateCreateFlagsNV(VkPipelineViewportSwizzleStateCreateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineDiscardRectangleStateCreateFlagsEXT(VkPipelineDiscardRectangleStateCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineRasterizationConservativeStateCreateFlagsEXT(VkPipelineRasterizationConservativeStateCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(VkPipelineRasterizationDepthClipStateCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_IOS_MVK)
void dump_text_VkIOSSurfaceCreateFlagsMVK(VkIOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
void dump_text_VkMacOSSurfaceCreateFlagsMVK(VkMacOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_MACOS_MVK
void dump_text_VkDebugUtilsMessengerCallbackDataFlagsEXT(VkDebugUtilsMessengerCallbackDataFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDebugUtilsMessengerCreateFlagsEXT(VkDebugUtilsMessengerCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineCoverageToColorStateCreateFlagsNV(VkPipelineCoverageToColorStateCreateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkPipelineCoverageModulationStateCreateFlagsNV(VkPipelineCoverageModulationStateCreateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkValidationCacheCreateFlagsEXT(VkValidationCacheCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImagePipeSurfaceCreateFlagsFUCHSIA(VkImagePipeSurfaceCreateFlagsFUCHSIA object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkMetalSurfaceCreateFlagsEXT(VkMetalSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkPipelineCoverageReductionStateCreateFlagsNV(VkPipelineCoverageReductionStateCreateFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkHeadlessSurfaceCreateFlagsEXT(VkHeadlessSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkDeviceMemoryReportFlagsEXT(VkDeviceMemoryReportFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkVideoEncodeRateControlFlagsKHR(VkVideoEncodeRateControlFlagsKHR object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkAccelerationStructureMotionInfoFlagsNV(VkAccelerationStructureMotionInfoFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
void dump_text_VkAccelerationStructureMotionInstanceFlagsNV(VkAccelerationStructureMotionInstanceFlagsNV object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_VkDirectFBSurfaceCreateFlagsEXT(VkDirectFBSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImageFormatConstraintsFlagsFUCHSIA(VkImageFormatConstraintsFlagsFUCHSIA object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkScreenSurfaceCreateFlagsQNX(VkScreenSurfaceCreateFlagsQNX object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
void dump_text_VkDirectDriverLoadingFlagsLUNARG(VkDirectDriverLoadingFlagsLUNARG object, const ApiDumpSettings& settings, int indents)
{
    settings.stream() << object;
}

//======================= Func Pointer Implementations ======================//

void dump_text_PFN_vkAllocationFunction(PFN_vkAllocationFunction object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkFreeFunction(PFN_vkFreeFunction object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkInternalAllocationNotification(PFN_vkInternalAllocationNotification object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkInternalFreeNotification(PFN_vkInternalFreeNotification object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkReallocationFunction(PFN_vkReallocationFunction object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkVoidFunction(PFN_vkVoidFunction object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkDebugReportCallbackEXT(PFN_vkDebugReportCallbackEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkDebugUtilsMessengerCallbackEXT(PFN_vkDebugUtilsMessengerCallbackEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkDeviceMemoryReportCallbackEXT(PFN_vkDeviceMemoryReportCallbackEXT object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}
void dump_text_PFN_vkGetInstanceProcAddrLUNARG(PFN_vkGetInstanceProcAddrLUNARG object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << object;
    else
        settings.stream() << "address";
}

//========================== Struct Implementations =========================//

void dump_text_VkExtent2D(const VkExtent2D& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkExtent3D(const VkExtent3D& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.depth, settings, "uint32_t", "depth", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkOffset2D(const VkOffset2D& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const int32_t>(object.x, settings, "int32_t", "x", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.y, settings, "int32_t", "y", indents + 1, dump_text_int32_t);  // AET
}
void dump_text_VkOffset3D(const VkOffset3D& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const int32_t>(object.x, settings, "int32_t", "x", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.y, settings, "int32_t", "y", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.z, settings, "int32_t", "z", indents + 1, dump_text_int32_t);  // AET
}
void dump_text_VkRect2D(const VkRect2D& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkOffset2D>(object.offset, settings, "VkOffset2D", "offset", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.extent, settings, "VkExtent2D", "extent", indents + 1, dump_text_VkExtent2D);  // AET
}
void dump_text_VkBaseInStructure(const VkBaseInStructure& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pointer<const VkBaseInStructure>(object.pNext, settings, "const struct VkBaseInStructure*", "pNext", indents + 1, dump_text_VkBaseInStructure);
}
void dump_text_VkBaseOutStructure(const VkBaseOutStructure& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pointer<const VkBaseOutStructure>(object.pNext, settings, "struct VkBaseOutStructure*", "pNext", indents + 1, dump_text_VkBaseOutStructure);
}
void dump_text_VkBufferMemoryBarrier(const VkBufferMemoryBarrier& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccessFlags>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDispatchIndirectCommand(const VkDispatchIndirectCommand& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.x, settings, "uint32_t", "x", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.y, settings, "uint32_t", "y", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.z, settings, "uint32_t", "z", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.firstIndex, settings, "uint32_t", "firstIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const int32_t>(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const uint32_t>(object.firstInstance, settings, "uint32_t", "firstInstance", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkDrawIndirectCommand(const VkDrawIndirectCommand& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.firstInstance, settings, "uint32_t", "firstInstance", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkImageSubresourceRange(const VkImageSubresourceRange& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    dump_text_value<const uint32_t>(object.baseMipLevel, settings, "uint32_t", "baseMipLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.levelCount, settings, "uint32_t", "levelCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkImageMemoryBarrier(const VkImageMemoryBarrier& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccessFlags>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkImageLayout>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageSubresourceRange>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + 1, dump_text_VkImageSubresourceRange);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryBarrier(const VkMemoryBarrier& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccessFlags>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.headerSize, settings, "uint32_t", "headerSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipelineCacheHeaderVersion>(object.headerVersion, settings, "VkPipelineCacheHeaderVersion", "headerVersion", indents + 1, dump_text_VkPipelineCacheHeaderVersion);  // AET
    dump_text_value<const uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint8_t>(object.pipelineCacheUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "pipelineCacheUUID", indents + 1, dump_text_uint8_t); // AQA
}
void dump_text_VkAllocationCallbacks(const VkAllocationCallbacks& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const void*>(object.pUserData, settings, "void*", "pUserData", indents + 1, dump_text_void);  // AET
    dump_text_value<const PFN_vkAllocationFunction>(object.pfnAllocation, settings, "PFN_vkAllocationFunction", "pfnAllocation", indents + 1, dump_text_PFN_vkAllocationFunction);  // AET
    dump_text_value<const PFN_vkReallocationFunction>(object.pfnReallocation, settings, "PFN_vkReallocationFunction", "pfnReallocation", indents + 1, dump_text_PFN_vkReallocationFunction);  // AET
    dump_text_value<const PFN_vkFreeFunction>(object.pfnFree, settings, "PFN_vkFreeFunction", "pfnFree", indents + 1, dump_text_PFN_vkFreeFunction);  // AET
    dump_text_value<const PFN_vkInternalAllocationNotification>(object.pfnInternalAllocation, settings, "PFN_vkInternalAllocationNotification", "pfnInternalAllocation", indents + 1, dump_text_PFN_vkInternalAllocationNotification);  // AET
    dump_text_value<const PFN_vkInternalFreeNotification>(object.pfnInternalFree, settings, "PFN_vkInternalFreeNotification", "pfnInternalFree", indents + 1, dump_text_PFN_vkInternalFreeNotification);  // AET
}
void dump_text_VkApplicationInfo(const VkApplicationInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const char*>(object.pApplicationName, settings, "const char*", "pApplicationName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const char*>(object.pEngineName, settings, "const char*", "pEngineName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.engineVersion, settings, "uint32_t", "engineVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFormatProperties(const VkFormatProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkFormatFeatureFlags>(object.linearTilingFeatures, settings, "VkFormatFeatureFlags", "linearTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags", "optimalTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.bufferFeatures, settings, "VkFormatFeatureFlags", "bufferFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
}
void dump_text_VkImageFormatProperties(const VkImageFormatProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkExtent3D>(object.maxExtent, settings, "VkExtent3D", "maxExtent", indents + 1, dump_text_VkExtent3D);  // AET
    dump_text_value<const uint32_t>(object.maxMipLevels, settings, "uint32_t", "maxMipLevels", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxArrayLayers, settings, "uint32_t", "maxArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleCountFlags>(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkDeviceSize>(object.maxResourceSize, settings, "VkDeviceSize", "maxResourceSize", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkInstanceCreateInfo(const VkInstanceCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkInstanceCreateFlags>(object.flags, settings, "VkInstanceCreateFlags", "flags", indents + 1, dump_text_VkInstanceCreateFlags);  // AET
    dump_text_pointer<const VkApplicationInfo>(object.pApplicationInfo, settings, "const VkApplicationInfo*", "pApplicationInfo", indents + 1, dump_text_VkApplicationInfo);
    dump_text_value<const uint32_t>(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const char*>(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "const char* const", "ppEnabledLayerNames", indents + 1, dump_text_cstring); // BQB
    dump_text_value<const uint32_t>(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const char*>(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "const char* const", "ppEnabledExtensionNames", indents + 1, dump_text_cstring); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryHeap(const VkMemoryHeap& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkMemoryHeapFlags>(object.flags, settings, "VkMemoryHeapFlags", "flags", indents + 1, dump_text_VkMemoryHeapFlags);  // AET
}
void dump_text_VkMemoryType(const VkMemoryType& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkMemoryPropertyFlags>(object.propertyFlags, settings, "VkMemoryPropertyFlags", "propertyFlags", indents + 1, dump_text_VkMemoryPropertyFlags);  // AET
    dump_text_value<const uint32_t>(object.heapIndex, settings, "uint32_t", "heapIndex", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBool32>(object.robustBufferAccess, settings, "VkBool32", "robustBufferAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fullDrawIndexUint32, settings, "VkBool32", "fullDrawIndexUint32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.imageCubeArray, settings, "VkBool32", "imageCubeArray", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.independentBlend, settings, "VkBool32", "independentBlend", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.geometryShader, settings, "VkBool32", "geometryShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tessellationShader, settings, "VkBool32", "tessellationShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sampleRateShading, settings, "VkBool32", "sampleRateShading", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dualSrcBlend, settings, "VkBool32", "dualSrcBlend", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.logicOp, settings, "VkBool32", "logicOp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiDrawIndirect, settings, "VkBool32", "multiDrawIndirect", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.drawIndirectFirstInstance, settings, "VkBool32", "drawIndirectFirstInstance", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthClamp, settings, "VkBool32", "depthClamp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthBiasClamp, settings, "VkBool32", "depthBiasClamp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fillModeNonSolid, settings, "VkBool32", "fillModeNonSolid", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthBounds, settings, "VkBool32", "depthBounds", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.wideLines, settings, "VkBool32", "wideLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.largePoints, settings, "VkBool32", "largePoints", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.alphaToOne, settings, "VkBool32", "alphaToOne", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiViewport, settings, "VkBool32", "multiViewport", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.samplerAnisotropy, settings, "VkBool32", "samplerAnisotropy", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureCompressionETC2, settings, "VkBool32", "textureCompressionETC2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureCompressionASTC_LDR, settings, "VkBool32", "textureCompressionASTC_LDR", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureCompressionBC, settings, "VkBool32", "textureCompressionBC", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.occlusionQueryPrecise, settings, "VkBool32", "occlusionQueryPrecise", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineStatisticsQuery, settings, "VkBool32", "pipelineStatisticsQuery", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vertexPipelineStoresAndAtomics, settings, "VkBool32", "vertexPipelineStoresAndAtomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentStoresAndAtomics, settings, "VkBool32", "fragmentStoresAndAtomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTessellationAndGeometryPointSize, settings, "VkBool32", "shaderTessellationAndGeometryPointSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderImageGatherExtended, settings, "VkBool32", "shaderImageGatherExtended", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageExtendedFormats, settings, "VkBool32", "shaderStorageImageExtendedFormats", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageMultisample, settings, "VkBool32", "shaderStorageImageMultisample", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageReadWithoutFormat, settings, "VkBool32", "shaderStorageImageReadWithoutFormat", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageWriteWithoutFormat, settings, "VkBool32", "shaderStorageImageWriteWithoutFormat", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampledImageArrayDynamicIndexing, settings, "VkBool32", "shaderSampledImageArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageArrayDynamicIndexing, settings, "VkBool32", "shaderStorageImageArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderClipDistance, settings, "VkBool32", "shaderClipDistance", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderCullDistance, settings, "VkBool32", "shaderCullDistance", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderFloat64, settings, "VkBool32", "shaderFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInt64, settings, "VkBool32", "shaderInt64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInt16, settings, "VkBool32", "shaderInt16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderResourceResidency, settings, "VkBool32", "shaderResourceResidency", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderResourceMinLod, settings, "VkBool32", "shaderResourceMinLod", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseBinding, settings, "VkBool32", "sparseBinding", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidencyBuffer, settings, "VkBool32", "sparseResidencyBuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidencyImage2D, settings, "VkBool32", "sparseResidencyImage2D", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidencyImage3D, settings, "VkBool32", "sparseResidencyImage3D", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidency2Samples, settings, "VkBool32", "sparseResidency2Samples", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidency4Samples, settings, "VkBool32", "sparseResidency4Samples", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidency8Samples, settings, "VkBool32", "sparseResidency8Samples", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidency16Samples, settings, "VkBool32", "sparseResidency16Samples", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseResidencyAliased, settings, "VkBool32", "sparseResidencyAliased", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.variableMultisampleRate, settings, "VkBool32", "variableMultisampleRate", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.inheritedQueries, settings, "VkBool32", "inheritedQueries", indents + 1, dump_text_VkBool32);  // AET
}
void dump_text_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.maxImageDimension1D, settings, "uint32_t", "maxImageDimension1D", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageDimension2D, settings, "uint32_t", "maxImageDimension2D", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageDimension3D, settings, "uint32_t", "maxImageDimension3D", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageDimensionCube, settings, "uint32_t", "maxImageDimensionCube", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTexelBufferElements, settings, "uint32_t", "maxTexelBufferElements", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxUniformBufferRange, settings, "uint32_t", "maxUniformBufferRange", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStorageBufferRange, settings, "uint32_t", "maxStorageBufferRange", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPushConstantsSize, settings, "uint32_t", "maxPushConstantsSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMemoryAllocationCount, settings, "uint32_t", "maxMemoryAllocationCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSamplerAllocationCount, settings, "uint32_t", "maxSamplerAllocationCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.bufferImageGranularity, settings, "VkDeviceSize", "bufferImageGranularity", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.sparseAddressSpaceSize, settings, "VkDeviceSize", "sparseAddressSpaceSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.maxBoundDescriptorSets, settings, "uint32_t", "maxBoundDescriptorSets", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorSamplers, settings, "uint32_t", "maxPerStageDescriptorSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorSampledImages, settings, "uint32_t", "maxPerStageDescriptorSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorStorageImages, settings, "uint32_t", "maxPerStageDescriptorStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorInputAttachments, settings, "uint32_t", "maxPerStageDescriptorInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageResources, settings, "uint32_t", "maxPerStageResources", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetSamplers, settings, "uint32_t", "maxDescriptorSetSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUniformBuffers, settings, "uint32_t", "maxDescriptorSetUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUniformBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetStorageBuffers, settings, "uint32_t", "maxDescriptorSetStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetStorageBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetSampledImages, settings, "uint32_t", "maxDescriptorSetSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetStorageImages, settings, "uint32_t", "maxDescriptorSetStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetInputAttachments, settings, "uint32_t", "maxDescriptorSetInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexInputAttributes, settings, "uint32_t", "maxVertexInputAttributes", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexInputBindings, settings, "uint32_t", "maxVertexInputBindings", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexInputAttributeOffset, settings, "uint32_t", "maxVertexInputAttributeOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexInputBindingStride, settings, "uint32_t", "maxVertexInputBindingStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexOutputComponents, settings, "uint32_t", "maxVertexOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationGenerationLevel, settings, "uint32_t", "maxTessellationGenerationLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationPatchSize, settings, "uint32_t", "maxTessellationPatchSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationControlPerVertexInputComponents, settings, "uint32_t", "maxTessellationControlPerVertexInputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationControlPerVertexOutputComponents, settings, "uint32_t", "maxTessellationControlPerVertexOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationControlPerPatchOutputComponents, settings, "uint32_t", "maxTessellationControlPerPatchOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationControlTotalOutputComponents, settings, "uint32_t", "maxTessellationControlTotalOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationEvaluationInputComponents, settings, "uint32_t", "maxTessellationEvaluationInputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTessellationEvaluationOutputComponents, settings, "uint32_t", "maxTessellationEvaluationOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryShaderInvocations, settings, "uint32_t", "maxGeometryShaderInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryInputComponents, settings, "uint32_t", "maxGeometryInputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryOutputComponents, settings, "uint32_t", "maxGeometryOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryOutputVertices, settings, "uint32_t", "maxGeometryOutputVertices", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryTotalOutputComponents, settings, "uint32_t", "maxGeometryTotalOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentInputComponents, settings, "uint32_t", "maxFragmentInputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentOutputAttachments, settings, "uint32_t", "maxFragmentOutputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentDualSrcAttachments, settings, "uint32_t", "maxFragmentDualSrcAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentCombinedOutputResources, settings, "uint32_t", "maxFragmentCombinedOutputResources", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxComputeSharedMemorySize, settings, "uint32_t", "maxComputeSharedMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxComputeWorkGroupCount, 3, settings, "uint32_t[3]", "uint32_t", "maxComputeWorkGroupCount", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxComputeWorkGroupInvocations, settings, "uint32_t", "maxComputeWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxComputeWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxComputeWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.subPixelPrecisionBits, settings, "uint32_t", "subPixelPrecisionBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.subTexelPrecisionBits, settings, "uint32_t", "subTexelPrecisionBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.mipmapPrecisionBits, settings, "uint32_t", "mipmapPrecisionBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDrawIndexedIndexValue, settings, "uint32_t", "maxDrawIndexedIndexValue", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDrawIndirectCount, settings, "uint32_t", "maxDrawIndirectCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const float>(object.maxSamplerLodBias, settings, "float", "maxSamplerLodBias", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxSamplerAnisotropy, settings, "float", "maxSamplerAnisotropy", indents + 1, dump_text_float);  // AET
    dump_text_value<const uint32_t>(object.maxViewports, settings, "uint32_t", "maxViewports", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxViewportDimensions, 2, settings, "uint32_t[2]", "uint32_t", "maxViewportDimensions", indents + 1, dump_text_uint32_t); // AQA
    dump_text_array<const float>(object.viewportBoundsRange, 2, settings, "float[2]", "float", "viewportBoundsRange", indents + 1, dump_text_float); // AQA
    dump_text_value<const uint32_t>(object.viewportSubPixelBits, settings, "uint32_t", "viewportSubPixelBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.minMemoryMapAlignment, settings, "size_t", "minMemoryMapAlignment", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const VkDeviceSize>(object.minTexelBufferOffsetAlignment, settings, "VkDeviceSize", "minTexelBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.minUniformBufferOffsetAlignment, settings, "VkDeviceSize", "minUniformBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.minStorageBufferOffsetAlignment, settings, "VkDeviceSize", "minStorageBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const int32_t>(object.minTexelOffset, settings, "int32_t", "minTexelOffset", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTexelOffset, settings, "uint32_t", "maxTexelOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const int32_t>(object.minTexelGatherOffset, settings, "int32_t", "minTexelGatherOffset", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTexelGatherOffset, settings, "uint32_t", "maxTexelGatherOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const float>(object.minInterpolationOffset, settings, "float", "minInterpolationOffset", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxInterpolationOffset, settings, "float", "maxInterpolationOffset", indents + 1, dump_text_float);  // AET
    dump_text_value<const uint32_t>(object.subPixelInterpolationOffsetBits, settings, "uint32_t", "subPixelInterpolationOffsetBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFramebufferWidth, settings, "uint32_t", "maxFramebufferWidth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFramebufferHeight, settings, "uint32_t", "maxFramebufferHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFramebufferLayers, settings, "uint32_t", "maxFramebufferLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleCountFlags>(object.framebufferColorSampleCounts, settings, "VkSampleCountFlags", "framebufferColorSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.framebufferDepthSampleCounts, settings, "VkSampleCountFlags", "framebufferDepthSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.framebufferStencilSampleCounts, settings, "VkSampleCountFlags", "framebufferStencilSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.framebufferNoAttachmentsSampleCounts, settings, "VkSampleCountFlags", "framebufferNoAttachmentsSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const uint32_t>(object.maxColorAttachments, settings, "uint32_t", "maxColorAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleCountFlags>(object.sampledImageColorSampleCounts, settings, "VkSampleCountFlags", "sampledImageColorSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.sampledImageIntegerSampleCounts, settings, "VkSampleCountFlags", "sampledImageIntegerSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.sampledImageDepthSampleCounts, settings, "VkSampleCountFlags", "sampledImageDepthSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.sampledImageStencilSampleCounts, settings, "VkSampleCountFlags", "sampledImageStencilSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.storageImageSampleCounts, settings, "VkSampleCountFlags", "storageImageSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const uint32_t>(object.maxSampleMaskWords, settings, "uint32_t", "maxSampleMaskWords", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.timestampComputeAndGraphics, settings, "VkBool32", "timestampComputeAndGraphics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const float>(object.timestampPeriod, settings, "float", "timestampPeriod", indents + 1, dump_text_float);  // AET
    dump_text_value<const uint32_t>(object.maxClipDistances, settings, "uint32_t", "maxClipDistances", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxCullDistances, settings, "uint32_t", "maxCullDistances", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxCombinedClipAndCullDistances, settings, "uint32_t", "maxCombinedClipAndCullDistances", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.discreteQueuePriorities, settings, "uint32_t", "discreteQueuePriorities", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const float>(object.pointSizeRange, 2, settings, "float[2]", "float", "pointSizeRange", indents + 1, dump_text_float); // AQA
    dump_text_array<const float>(object.lineWidthRange, 2, settings, "float[2]", "float", "lineWidthRange", indents + 1, dump_text_float); // AQA
    dump_text_value<const float>(object.pointSizeGranularity, settings, "float", "pointSizeGranularity", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.lineWidthGranularity, settings, "float", "lineWidthGranularity", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkBool32>(object.strictLines, settings, "VkBool32", "strictLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.standardSampleLocations, settings, "VkBool32", "standardSampleLocations", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.optimalBufferCopyOffsetAlignment, settings, "VkDeviceSize", "optimalBufferCopyOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.optimalBufferCopyRowPitchAlignment, settings, "VkDeviceSize", "optimalBufferCopyRowPitchAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.nonCoherentAtomSize, settings, "VkDeviceSize", "nonCoherentAtomSize", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.memoryTypeCount, settings, "uint32_t", "memoryTypeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMemoryType>(object.memoryTypes, object.memoryTypeCount, settings, "VkMemoryType[VK_MAX_MEMORY_TYPES]", "VkMemoryType", "memoryTypes", indents + 1, dump_text_VkMemoryType); // BQB
    dump_text_value<const uint32_t>(object.memoryHeapCount, settings, "uint32_t", "memoryHeapCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMemoryHeap>(object.memoryHeaps, object.memoryHeapCount, settings, "VkMemoryHeap[VK_MAX_MEMORY_HEAPS]", "VkMemoryHeap", "memoryHeaps", indents + 1, dump_text_VkMemoryHeap); // BQB
}
void dump_text_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBool32>(object.residencyStandard2DBlockShape, settings, "VkBool32", "residencyStandard2DBlockShape", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.residencyStandard2DMultisampleBlockShape, settings, "VkBool32", "residencyStandard2DMultisampleBlockShape", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.residencyStandard3DBlockShape, settings, "VkBool32", "residencyStandard3DBlockShape", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.residencyAlignedMipSize, settings, "VkBool32", "residencyAlignedMipSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.residencyNonResidentStrict, settings, "VkBool32", "residencyNonResidentStrict", indents + 1, dump_text_VkBool32);  // AET
}
void dump_text_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.driverVersion, settings, "uint32_t", "driverVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPhysicalDeviceType>(object.deviceType, settings, "VkPhysicalDeviceType", "deviceType", indents + 1, dump_text_VkPhysicalDeviceType);  // AET
    dump_text_value<const char*>(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + 1, dump_text_cstring);  // AET
    dump_text_array<const uint8_t>(object.pipelineCacheUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "pipelineCacheUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const VkPhysicalDeviceLimits>(object.limits, settings, "VkPhysicalDeviceLimits", "limits", indents + 1, dump_text_VkPhysicalDeviceLimits);  // AET
    dump_text_value<const VkPhysicalDeviceSparseProperties>(object.sparseProperties, settings, "VkPhysicalDeviceSparseProperties", "sparseProperties", indents + 1, dump_text_VkPhysicalDeviceSparseProperties);  // AET
}
void dump_text_VkQueueFamilyProperties(const VkQueueFamilyProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkQueueFlags>(object.queueFlags, settings, "VkQueueFlags", "queueFlags", indents + 1, dump_text_VkQueueFlags);  // AET
    dump_text_value<const uint32_t>(object.queueCount, settings, "uint32_t", "queueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.timestampValidBits, settings, "uint32_t", "timestampValidBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent3D>(object.minImageTransferGranularity, settings, "VkExtent3D", "minImageTransferGranularity", indents + 1, dump_text_VkExtent3D);  // AET
}
void dump_text_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceQueueCreateFlags>(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + 1, dump_text_VkDeviceQueueCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.queueCount, settings, "uint32_t", "queueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const float>(object.pQueuePriorities, object.queueCount, settings, "const float*", "const float", "pQueuePriorities", indents + 1, dump_text_float); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceCreateInfo(const VkDeviceCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceCreateFlags>(object.flags, settings, "VkDeviceCreateFlags", "flags", indents + 1, dump_text_VkDeviceCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.queueCreateInfoCount, settings, "uint32_t", "queueCreateInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceQueueCreateInfo>(object.pQueueCreateInfos, object.queueCreateInfoCount, settings, "const VkDeviceQueueCreateInfo*", "const VkDeviceQueueCreateInfo", "pQueueCreateInfos", indents + 1, dump_text_VkDeviceQueueCreateInfo); // BQB
    dump_text_value<const uint32_t>(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const char*>(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "const char* const", "ppEnabledLayerNames", indents + 1, dump_text_cstring); // BQB
    dump_text_value<const uint32_t>(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const char*>(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "const char* const", "ppEnabledExtensionNames", indents + 1, dump_text_cstring); // BQB
    dump_text_pointer<const VkPhysicalDeviceFeatures>(object.pEnabledFeatures, settings, "const VkPhysicalDeviceFeatures*", "pEnabledFeatures", indents + 1, dump_text_VkPhysicalDeviceFeatures);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExtensionProperties(const VkExtensionProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const char*>(object.extensionName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "extensionName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.specVersion, settings, "uint32_t", "specVersion", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkLayerProperties(const VkLayerProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const char*>(object.layerName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layerName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.specVersion, settings, "uint32_t", "specVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.implementationVersion, settings, "uint32_t", "implementationVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
}
void dump_text_VkSubmitInfo(const VkSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pWaitSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    dump_text_array<const VkPipelineStageFlags>(object.pWaitDstStageMask, object.waitSemaphoreCount, settings, "const VkPipelineStageFlags*", "const VkPipelineStageFlags", "pWaitDstStageMask", indents + 1, dump_text_VkPipelineStageFlags); // BQB
    dump_text_value<const uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkCommandBuffer>(object.pCommandBuffers, object.commandBufferCount, settings, "const VkCommandBuffer*", "const VkCommandBuffer", "pCommandBuffers", indents + 1, dump_text_VkCommandBuffer); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pSignalSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMappedMemoryRange(const VkMappedMemoryRange& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryAllocateInfo(const VkMemoryAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.memoryTypeIndex, settings, "uint32_t", "memoryTypeIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryRequirements(const VkMemoryRequirements& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.alignment, settings, "VkDeviceSize", "alignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkSparseMemoryBind(const VkSparseMemoryBind& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.resourceOffset, settings, "VkDeviceSize", "resourceOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkSparseMemoryBindFlags>(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + 1, dump_text_VkSparseMemoryBindFlags);  // AET
}
void dump_text_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseMemoryBind>(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "const VkSparseMemoryBind", "pBinds", indents + 1, dump_text_VkSparseMemoryBind); // BQB
}
void dump_text_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseMemoryBind>(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "const VkSparseMemoryBind", "pBinds", indents + 1, dump_text_VkSparseMemoryBind); // BQB
}
void dump_text_VkImageSubresource(const VkImageSubresource& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    dump_text_value<const uint32_t>(object.mipLevel, settings, "uint32_t", "mipLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.arrayLayer, settings, "uint32_t", "arrayLayer", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkSparseImageMemoryBind(const VkSparseImageMemoryBind& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageSubresource>(object.subresource, settings, "VkImageSubresource", "subresource", indents + 1, dump_text_VkImageSubresource);  // AET
    dump_text_value<const VkOffset3D>(object.offset, settings, "VkOffset3D", "offset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkSparseMemoryBindFlags>(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + 1, dump_text_VkSparseMemoryBindFlags);  // AET
}
void dump_text_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const uint32_t>(object.bindCount, settings, "uint32_t", "bindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseImageMemoryBind>(object.pBinds, object.bindCount, settings, "const VkSparseImageMemoryBind*", "const VkSparseImageMemoryBind", "pBinds", indents + 1, dump_text_VkSparseImageMemoryBind); // BQB
}
void dump_text_VkBindSparseInfo(const VkBindSparseInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pWaitSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    dump_text_value<const uint32_t>(object.bufferBindCount, settings, "uint32_t", "bufferBindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseBufferMemoryBindInfo>(object.pBufferBinds, object.bufferBindCount, settings, "const VkSparseBufferMemoryBindInfo*", "const VkSparseBufferMemoryBindInfo", "pBufferBinds", indents + 1, dump_text_VkSparseBufferMemoryBindInfo); // BQB
    dump_text_value<const uint32_t>(object.imageOpaqueBindCount, settings, "uint32_t", "imageOpaqueBindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseImageOpaqueMemoryBindInfo>(object.pImageOpaqueBinds, object.imageOpaqueBindCount, settings, "const VkSparseImageOpaqueMemoryBindInfo*", "const VkSparseImageOpaqueMemoryBindInfo", "pImageOpaqueBinds", indents + 1, dump_text_VkSparseImageOpaqueMemoryBindInfo); // BQB
    dump_text_value<const uint32_t>(object.imageBindCount, settings, "uint32_t", "imageBindCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSparseImageMemoryBindInfo>(object.pImageBinds, object.imageBindCount, settings, "const VkSparseImageMemoryBindInfo*", "const VkSparseImageMemoryBindInfo", "pImageBinds", indents + 1, dump_text_VkSparseImageMemoryBindInfo); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pSignalSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSparseImageFormatProperties(const VkSparseImageFormatProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    dump_text_value<const VkExtent3D>(object.imageGranularity, settings, "VkExtent3D", "imageGranularity", indents + 1, dump_text_VkExtent3D);  // AET
    dump_text_value<const VkSparseImageFormatFlags>(object.flags, settings, "VkSparseImageFormatFlags", "flags", indents + 1, dump_text_VkSparseImageFormatFlags);  // AET
}
void dump_text_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkSparseImageFormatProperties>(object.formatProperties, settings, "VkSparseImageFormatProperties", "formatProperties", indents + 1, dump_text_VkSparseImageFormatProperties);  // AET
    dump_text_value<const uint32_t>(object.imageMipTailFirstLod, settings, "uint32_t", "imageMipTailFirstLod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.imageMipTailSize, settings, "VkDeviceSize", "imageMipTailSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.imageMipTailOffset, settings, "VkDeviceSize", "imageMipTailOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.imageMipTailStride, settings, "VkDeviceSize", "imageMipTailStride", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkFenceCreateInfo(const VkFenceCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFenceCreateFlags>(object.flags, settings, "VkFenceCreateFlags", "flags", indents + 1, dump_text_VkFenceCreateFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphoreCreateFlags>(object.flags, settings, "VkSemaphoreCreateFlags", "flags", indents + 1, dump_text_VkSemaphoreCreateFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkEventCreateInfo(const VkEventCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkEventCreateFlags>(object.flags, settings, "VkEventCreateFlags", "flags", indents + 1, dump_text_VkEventCreateFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueryPoolCreateFlags>(object.flags, settings, "VkQueryPoolCreateFlags", "flags", indents + 1, dump_text_VkQueryPoolCreateFlags);  // AET
    dump_text_value<const VkQueryType>(object.queryType, settings, "VkQueryType", "queryType", indents + 1, dump_text_VkQueryType);  // AET
    dump_text_value<const uint32_t>(object.queryCount, settings, "uint32_t", "queryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkQueryPipelineStatisticFlags>(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + 1, dump_text_VkQueryPipelineStatisticFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferCreateInfo(const VkBufferCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCreateFlags>(object.flags, settings, "VkBufferCreateFlags", "flags", indents + 1, dump_text_VkBufferCreateFlags);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBufferUsageFlags>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + 1, dump_text_VkBufferUsageFlags);  // AET
    dump_text_value<const VkSharingMode>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + 1, dump_text_VkSharingMode);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.sharingMode == VK_SHARING_MODE_CONCURRENT)
    dump_text_array<const uint32_t>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "const uint32_t", "pQueueFamilyIndices", indents + 1, dump_text_uint32_t); // BQB
    else
        dump_text_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferViewCreateInfo(const VkBufferViewCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferViewCreateFlags>(object.flags, settings, "VkBufferViewCreateFlags", "flags", indents + 1, dump_text_VkBufferViewCreateFlags);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageCreateInfo(const VkImageCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageCreateFlags>(object.flags, settings, "VkImageCreateFlags", "flags", indents + 1, dump_text_VkImageCreateFlags);  // AET
    dump_text_value<const VkImageType>(object.imageType, settings, "VkImageType", "imageType", indents + 1, dump_text_VkImageType);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
    dump_text_value<const uint32_t>(object.mipLevels, settings, "uint32_t", "mipLevels", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.arrayLayers, settings, "uint32_t", "arrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkImageTiling>(object.tiling, settings, "VkImageTiling", "tiling", indents + 1, dump_text_VkImageTiling);  // AET
    dump_text_value<const VkImageUsageFlags>(object.usage, settings, "VkImageUsageFlags", "usage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkSharingMode>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + 1, dump_text_VkSharingMode);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.sharingMode == VK_SHARING_MODE_CONCURRENT)
    dump_text_array<const uint32_t>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "const uint32_t", "pQueueFamilyIndices", indents + 1, dump_text_uint32_t); // BQB
    else
        dump_text_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
    dump_text_value<const VkImageLayout>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + 1, dump_text_VkImageLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubresourceLayout(const VkSubresourceLayout& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.rowPitch, settings, "VkDeviceSize", "rowPitch", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.arrayPitch, settings, "VkDeviceSize", "arrayPitch", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.depthPitch, settings, "VkDeviceSize", "depthPitch", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkComponentMapping(const VkComponentMapping& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkComponentSwizzle>(object.r, settings, "VkComponentSwizzle", "r", indents + 1, dump_text_VkComponentSwizzle);  // AET
    dump_text_value<const VkComponentSwizzle>(object.g, settings, "VkComponentSwizzle", "g", indents + 1, dump_text_VkComponentSwizzle);  // AET
    dump_text_value<const VkComponentSwizzle>(object.b, settings, "VkComponentSwizzle", "b", indents + 1, dump_text_VkComponentSwizzle);  // AET
    dump_text_value<const VkComponentSwizzle>(object.a, settings, "VkComponentSwizzle", "a", indents + 1, dump_text_VkComponentSwizzle);  // AET
}
void dump_text_VkImageViewCreateInfo(const VkImageViewCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageViewCreateFlags>(object.flags, settings, "VkImageViewCreateFlags", "flags", indents + 1, dump_text_VkImageViewCreateFlags);  // AET
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageViewType>(object.viewType, settings, "VkImageViewType", "viewType", indents + 1, dump_text_VkImageViewType);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkComponentMapping>(object.components, settings, "VkComponentMapping", "components", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkImageSubresourceRange>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + 1, dump_text_VkImageSubresourceRange);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderModuleCreateFlags>(object.flags, settings, "VkShaderModuleCreateFlags", "flags", indents + 1, dump_text_VkShaderModuleCreateFlags);  // AET
    dump_text_value<const size_t>(object.codeSize, settings, "size_t", "codeSize", indents + 1, dump_text_size_t);  // AET
    if(settings.showShader())
        dump_text_array<const uint32_t>(object.pCode, object.codeSize / 4, settings, "const uint32_t*", "const uint32_t", "pCode", indents + 1, dump_text_uint32_t); // CQA
    else
        dump_text_special("SHADER DATA", settings, "const uint32_t*", "pCode", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCacheCreateFlags>(object.flags, settings, "VkPipelineCacheCreateFlags", "flags", indents + 1, dump_text_VkPipelineCacheCreateFlags);  // AET
    dump_text_value<const size_t>(object.initialDataSize, settings, "size_t", "initialDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pInitialData, settings, "const void*", "pInitialData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSpecializationMapEntry(const VkSpecializationMapEntry& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.constantID, settings, "uint32_t", "constantID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.size, settings, "size_t", "size", indents + 1, dump_text_size_t);  // AET
}
void dump_text_VkSpecializationInfo(const VkSpecializationInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.mapEntryCount, settings, "uint32_t", "mapEntryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSpecializationMapEntry>(object.pMapEntries, object.mapEntryCount, settings, "const VkSpecializationMapEntry*", "const VkSpecializationMapEntry", "pMapEntries", indents + 1, dump_text_VkSpecializationMapEntry); // BQB
    dump_text_value<const size_t>(object.dataSize, settings, "size_t", "dataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "const void*", "pData", indents + 1, dump_text_void);  // AET
}
void dump_text_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineShaderStageCreateFlags>(object.flags, settings, "VkPipelineShaderStageCreateFlags", "flags", indents + 1, dump_text_VkPipelineShaderStageCreateFlags);  // AET
    dump_text_value<const VkShaderStageFlagBits>(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + 1, dump_text_VkShaderStageFlagBits);  // AET
    dump_text_value<const VkShaderModule>(object.module, settings, "VkShaderModule", "module", indents + 1, dump_text_VkShaderModule);  // AET
    dump_text_value<const char*>(object.pName, settings, "const char*", "pName", indents + 1, dump_text_cstring);  // AET
    dump_text_pointer<const VkSpecializationInfo>(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + 1, dump_text_VkSpecializationInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + 1, dump_text_VkPipelineCreateFlags);  // AET
    dump_text_value<const VkPipelineShaderStageCreateInfo>(object.stage, settings, "VkPipelineShaderStageCreateInfo", "stage", indents + 1, dump_text_VkPipelineShaderStageCreateInfo);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkPipeline>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVertexInputBindingDescription(const VkVertexInputBindingDescription& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVertexInputRate>(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + 1, dump_text_VkVertexInputRate);  // AET
}
void dump_text_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.location, settings, "uint32_t", "location", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineVertexInputStateCreateFlags>(object.flags, settings, "VkPipelineVertexInputStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineVertexInputStateCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVertexInputBindingDescription>(object.pVertexBindingDescriptions, object.vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription*", "const VkVertexInputBindingDescription", "pVertexBindingDescriptions", indents + 1, dump_text_VkVertexInputBindingDescription); // BQB
    dump_text_value<const uint32_t>(object.vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVertexInputAttributeDescription>(object.pVertexAttributeDescriptions, object.vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription*", "const VkVertexInputAttributeDescription", "pVertexAttributeDescriptions", indents + 1, dump_text_VkVertexInputAttributeDescription); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineInputAssemblyStateCreateFlags>(object.flags, settings, "VkPipelineInputAssemblyStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineInputAssemblyStateCreateFlags);  // AET
    dump_text_value<const VkPrimitiveTopology>(object.topology, settings, "VkPrimitiveTopology", "topology", indents + 1, dump_text_VkPrimitiveTopology);  // AET
    dump_text_value<const VkBool32>(object.primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineTessellationStateCreateFlags>(object.flags, settings, "VkPipelineTessellationStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineTessellationStateCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.patchControlPoints, settings, "uint32_t", "patchControlPoints", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkViewport(const VkViewport& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.x, settings, "float", "x", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.y, settings, "float", "y", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.width, settings, "float", "width", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.height, settings, "float", "height", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.minDepth, settings, "float", "minDepth", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxDepth, settings, "float", "maxDepth", indents + 1, dump_text_float);  // AET
}
void dump_text_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineViewportStateCreateFlags>(object.flags, settings, "VkPipelineViewportStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineViewportStateCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + 1, dump_text_uint32_t);  // AET
    if(!ApiDumpInstance::current().getIsDynamicViewport())
    dump_text_array<const VkViewport>(object.pViewports, object.viewportCount, settings, "const VkViewport*", "const VkViewport", "pViewports", indents + 1, dump_text_VkViewport); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkViewport*", "pViewports", indents + 1);
    dump_text_value<const uint32_t>(object.scissorCount, settings, "uint32_t", "scissorCount", indents + 1, dump_text_uint32_t);  // AET
    if(!ApiDumpInstance::current().getIsDynamicScissor())
    dump_text_array<const VkRect2D>(object.pScissors, object.scissorCount, settings, "const VkRect2D*", "const VkRect2D", "pScissors", indents + 1, dump_text_VkRect2D); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkRect2D*", "pScissors", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineRasterizationStateCreateFlags>(object.flags, settings, "VkPipelineRasterizationStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineRasterizationStateCreateFlags);  // AET
    dump_text_value<const VkBool32>(object.depthClampEnable, settings, "VkBool32", "depthClampEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkPolygonMode>(object.polygonMode, settings, "VkPolygonMode", "polygonMode", indents + 1, dump_text_VkPolygonMode);  // AET
    dump_text_value<const VkCullModeFlags>(object.cullMode, settings, "VkCullModeFlags", "cullMode", indents + 1, dump_text_VkCullModeFlags);  // AET
    dump_text_value<const VkFrontFace>(object.frontFace, settings, "VkFrontFace", "frontFace", indents + 1, dump_text_VkFrontFace);  // AET
    dump_text_value<const VkBool32>(object.depthBiasEnable, settings, "VkBool32", "depthBiasEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const float>(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.lineWidth, settings, "float", "lineWidth", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineMultisampleStateCreateFlags>(object.flags, settings, "VkPipelineMultisampleStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineMultisampleStateCreateFlags);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkBool32>(object.sampleShadingEnable, settings, "VkBool32", "sampleShadingEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const float>(object.minSampleShading, settings, "float", "minSampleShading", indents + 1, dump_text_float);  // AET
    dump_text_array<const VkSampleMask>(object.pSampleMask, (object.rasterizationSamples + 31) / 32, settings, "const VkSampleMask*", "const VkSampleMask", "pSampleMask", indents + 1, dump_text_VkSampleMask); // BQB
    dump_text_value<const VkBool32>(object.alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkStencilOpState(const VkStencilOpState& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStencilOp>(object.failOp, settings, "VkStencilOp", "failOp", indents + 1, dump_text_VkStencilOp);  // AET
    dump_text_value<const VkStencilOp>(object.passOp, settings, "VkStencilOp", "passOp", indents + 1, dump_text_VkStencilOp);  // AET
    dump_text_value<const VkStencilOp>(object.depthFailOp, settings, "VkStencilOp", "depthFailOp", indents + 1, dump_text_VkStencilOp);  // AET
    dump_text_value<const VkCompareOp>(object.compareOp, settings, "VkCompareOp", "compareOp", indents + 1, dump_text_VkCompareOp);  // AET
    dump_text_value<const uint32_t>(object.compareMask, settings, "uint32_t", "compareMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.writeMask, settings, "uint32_t", "writeMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.reference, settings, "uint32_t", "reference", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineDepthStencilStateCreateFlags>(object.flags, settings, "VkPipelineDepthStencilStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineDepthStencilStateCreateFlags);  // AET
    dump_text_value<const VkBool32>(object.depthTestEnable, settings, "VkBool32", "depthTestEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthWriteEnable, settings, "VkBool32", "depthWriteEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkCompareOp>(object.depthCompareOp, settings, "VkCompareOp", "depthCompareOp", indents + 1, dump_text_VkCompareOp);  // AET
    dump_text_value<const VkBool32>(object.depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stencilTestEnable, settings, "VkBool32", "stencilTestEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkStencilOpState>(object.front, settings, "VkStencilOpState", "front", indents + 1, dump_text_VkStencilOpState);  // AET
    dump_text_value<const VkStencilOpState>(object.back, settings, "VkStencilOpState", "back", indents + 1, dump_text_VkStencilOpState);  // AET
    dump_text_value<const float>(object.minDepthBounds, settings, "float", "minDepthBounds", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxDepthBounds, settings, "float", "maxDepthBounds", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBool32>(object.blendEnable, settings, "VkBool32", "blendEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBlendFactor>(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendFactor>(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendOp>(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + 1, dump_text_VkBlendOp);  // AET
    dump_text_value<const VkBlendFactor>(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendFactor>(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendOp>(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + 1, dump_text_VkBlendOp);  // AET
    dump_text_value<const VkColorComponentFlags>(object.colorWriteMask, settings, "VkColorComponentFlags", "colorWriteMask", indents + 1, dump_text_VkColorComponentFlags);  // AET
}
void dump_text_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineColorBlendStateCreateFlags>(object.flags, settings, "VkPipelineColorBlendStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineColorBlendStateCreateFlags);  // AET
    dump_text_value<const VkBool32>(object.logicOpEnable, settings, "VkBool32", "logicOpEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkLogicOp>(object.logicOp, settings, "VkLogicOp", "logicOp", indents + 1, dump_text_VkLogicOp);  // AET
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineColorBlendAttachmentState>(object.pAttachments, object.attachmentCount, settings, "const VkPipelineColorBlendAttachmentState*", "const VkPipelineColorBlendAttachmentState", "pAttachments", indents + 1, dump_text_VkPipelineColorBlendAttachmentState); // BQB
    dump_text_array<const float>(object.blendConstants, 4, settings, "float[4]", "float", "blendConstants", indents + 1, dump_text_float); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineDynamicStateCreateFlags>(object.flags, settings, "VkPipelineDynamicStateCreateFlags", "flags", indents + 1, dump_text_VkPipelineDynamicStateCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.dynamicStateCount, settings, "uint32_t", "dynamicStateCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDynamicState>(object.pDynamicStates, object.dynamicStateCount, settings, "const VkDynamicState*", "const VkDynamicState", "pDynamicStates", indents + 1, dump_text_VkDynamicState); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    ApiDumpInstance::current().setIsDynamicViewport(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_VIEWPORT) > 0);ApiDumpInstance::current().setIsDynamicScissor(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_SCISSOR));ApiDumpInstance::current().setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object));
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + 1, dump_text_VkPipelineCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineShaderStageCreateInfo>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "const VkPipelineShaderStageCreateInfo", "pStages", indents + 1, dump_text_VkPipelineShaderStageCreateInfo); // BQB
    dump_text_pointer<const VkPipelineVertexInputStateCreateInfo>(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + 1, dump_text_VkPipelineVertexInputStateCreateInfo);
    dump_text_pointer<const VkPipelineInputAssemblyStateCreateInfo>(object.pInputAssemblyState, settings, "const VkPipelineInputAssemblyStateCreateInfo*", "pInputAssemblyState", indents + 1, dump_text_VkPipelineInputAssemblyStateCreateInfo);
    dump_text_pointer<const VkPipelineTessellationStateCreateInfo>(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + 1, dump_text_VkPipelineTessellationStateCreateInfo);
    dump_text_pointer<const VkPipelineViewportStateCreateInfo>(object.pViewportState, settings, "const VkPipelineViewportStateCreateInfo*", "pViewportState", indents + 1, dump_text_VkPipelineViewportStateCreateInfo);
    dump_text_pointer<const VkPipelineRasterizationStateCreateInfo>(object.pRasterizationState, settings, "const VkPipelineRasterizationStateCreateInfo*", "pRasterizationState", indents + 1, dump_text_VkPipelineRasterizationStateCreateInfo);
    dump_text_pointer<const VkPipelineMultisampleStateCreateInfo>(object.pMultisampleState, settings, "const VkPipelineMultisampleStateCreateInfo*", "pMultisampleState", indents + 1, dump_text_VkPipelineMultisampleStateCreateInfo);
    dump_text_pointer<const VkPipelineDepthStencilStateCreateInfo>(object.pDepthStencilState, settings, "const VkPipelineDepthStencilStateCreateInfo*", "pDepthStencilState", indents + 1, dump_text_VkPipelineDepthStencilStateCreateInfo);
    dump_text_pointer<const VkPipelineColorBlendStateCreateInfo>(object.pColorBlendState, settings, "const VkPipelineColorBlendStateCreateInfo*", "pColorBlendState", indents + 1, dump_text_VkPipelineColorBlendStateCreateInfo);
    dump_text_pointer<const VkPipelineDynamicStateCreateInfo>(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + 1, dump_text_VkPipelineDynamicStateCreateInfo);
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkRenderPass>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + 1, dump_text_VkRenderPass);  // AET
    dump_text_value<const uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipeline>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPushConstantRange(const VkPushConstantRange& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineLayoutCreateFlags>(object.flags, settings, "VkPipelineLayoutCreateFlags", "flags", indents + 1, dump_text_VkPipelineLayoutCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSetLayout>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "const VkDescriptorSetLayout", "pSetLayouts", indents + 1, dump_text_VkDescriptorSetLayout); // BQB
    dump_text_value<const uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPushConstantRange>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "const VkPushConstantRange", "pPushConstantRanges", indents + 1, dump_text_VkPushConstantRange); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerCreateInfo(const VkSamplerCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSamplerCreateFlags>(object.flags, settings, "VkSamplerCreateFlags", "flags", indents + 1, dump_text_VkSamplerCreateFlags);  // AET
    dump_text_value<const VkFilter>(object.magFilter, settings, "VkFilter", "magFilter", indents + 1, dump_text_VkFilter);  // AET
    dump_text_value<const VkFilter>(object.minFilter, settings, "VkFilter", "minFilter", indents + 1, dump_text_VkFilter);  // AET
    dump_text_value<const VkSamplerMipmapMode>(object.mipmapMode, settings, "VkSamplerMipmapMode", "mipmapMode", indents + 1, dump_text_VkSamplerMipmapMode);  // AET
    dump_text_value<const VkSamplerAddressMode>(object.addressModeU, settings, "VkSamplerAddressMode", "addressModeU", indents + 1, dump_text_VkSamplerAddressMode);  // AET
    dump_text_value<const VkSamplerAddressMode>(object.addressModeV, settings, "VkSamplerAddressMode", "addressModeV", indents + 1, dump_text_VkSamplerAddressMode);  // AET
    dump_text_value<const VkSamplerAddressMode>(object.addressModeW, settings, "VkSamplerAddressMode", "addressModeW", indents + 1, dump_text_VkSamplerAddressMode);  // AET
    dump_text_value<const float>(object.mipLodBias, settings, "float", "mipLodBias", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkBool32>(object.anisotropyEnable, settings, "VkBool32", "anisotropyEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const float>(object.maxAnisotropy, settings, "float", "maxAnisotropy", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkBool32>(object.compareEnable, settings, "VkBool32", "compareEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkCompareOp>(object.compareOp, settings, "VkCompareOp", "compareOp", indents + 1, dump_text_VkCompareOp);  // AET
    dump_text_value<const float>(object.minLod, settings, "float", "minLod", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxLod, settings, "float", "maxLod", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkBorderColor>(object.borderColor, settings, "VkBorderColor", "borderColor", indents + 1, dump_text_VkBorderColor);  // AET
    dump_text_value<const VkBool32>(object.unnormalizedCoordinates, settings, "VkBool32", "unnormalizedCoordinates", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyDescriptorSet(const VkCopyDescriptorSet& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorSet>(object.srcSet, settings, "VkDescriptorSet", "srcSet", indents + 1, dump_text_VkDescriptorSet);  // AET
    dump_text_value<const uint32_t>(object.srcBinding, settings, "uint32_t", "srcBinding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.srcArrayElement, settings, "uint32_t", "srcArrayElement", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDescriptorSet>(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + 1, dump_text_VkDescriptorSet);  // AET
    dump_text_value<const uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorBufferInfo(const VkDescriptorBufferInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkDescriptorImageInfo(const VkDescriptorImageInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkSampler>(object.sampler, settings, "VkSampler", "sampler", indents + 1, dump_text_VkSampler);  // AET
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkImageLayout>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + 1, dump_text_VkImageLayout);  // AET
}
void dump_text_VkDescriptorPoolSize(const VkDescriptorPoolSize& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDescriptorType>(object.type, settings, "VkDescriptorType", "type", indents + 1, dump_text_VkDescriptorType);  // AET
    dump_text_value<const uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorPoolCreateFlags>(object.flags, settings, "VkDescriptorPoolCreateFlags", "flags", indents + 1, dump_text_VkDescriptorPoolCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.maxSets, settings, "uint32_t", "maxSets", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.poolSizeCount, settings, "uint32_t", "poolSizeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorPoolSize>(object.pPoolSizes, object.poolSizeCount, settings, "const VkDescriptorPoolSize*", "const VkDescriptorPoolSize", "pPoolSizes", indents + 1, dump_text_VkDescriptorPoolSize); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorPool>(object.descriptorPool, settings, "VkDescriptorPool", "descriptorPool", indents + 1, dump_text_VkDescriptorPool);  // AET
    dump_text_value<const uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSetLayout>(object.pSetLayouts, object.descriptorSetCount, settings, "const VkDescriptorSetLayout*", "const VkDescriptorSetLayout", "pSetLayouts", indents + 1, dump_text_VkDescriptorSetLayout); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDescriptorType>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + 1, dump_text_VkDescriptorType);  // AET
    dump_text_value<const uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    if((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER))
    dump_text_array<const VkSampler>(object.pImmutableSamplers, object.descriptorCount, settings, "const VkSampler*", "const VkSampler", "pImmutableSamplers", indents + 1, dump_text_VkSampler); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkSampler*", "pImmutableSamplers", indents + 1);
}
void dump_text_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorSetLayoutCreateFlags>(object.flags, settings, "VkDescriptorSetLayoutCreateFlags", "flags", indents + 1, dump_text_VkDescriptorSetLayoutCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.bindingCount, settings, "uint32_t", "bindingCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSetLayoutBinding>(object.pBindings, object.bindingCount, settings, "const VkDescriptorSetLayoutBinding*", "const VkDescriptorSetLayoutBinding", "pBindings", indents + 1, dump_text_VkDescriptorSetLayoutBinding); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteDescriptorSet(const VkWriteDescriptorSet& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorSet>(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + 1, dump_text_VkDescriptorSet);  // AET
    dump_text_value<const uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDescriptorType>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + 1, dump_text_VkDescriptorType);  // AET
    if((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT))
    dump_text_array<const VkDescriptorImageInfo>(object.pImageInfo, object.descriptorCount, settings, "const VkDescriptorImageInfo*", "const VkDescriptorImageInfo", "pImageInfo", indents + 1, dump_text_VkDescriptorImageInfo); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkDescriptorImageInfo*", "pImageInfo", indents + 1);
    if((object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC))
    dump_text_array<const VkDescriptorBufferInfo>(object.pBufferInfo, object.descriptorCount, settings, "const VkDescriptorBufferInfo*", "const VkDescriptorBufferInfo", "pBufferInfo", indents + 1, dump_text_VkDescriptorBufferInfo); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 1);
    if((object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER))
    dump_text_array<const VkBufferView>(object.pTexelBufferView, object.descriptorCount, settings, "const VkBufferView*", "const VkBufferView", "pTexelBufferView", indents + 1, dump_text_VkBufferView); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkBufferView*", "pTexelBufferView", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentDescription(const VkAttachmentDescription& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkAttachmentDescriptionFlags>(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + 1, dump_text_VkAttachmentDescriptionFlags);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkAttachmentLoadOp>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + 1, dump_text_VkAttachmentLoadOp);  // AET
    dump_text_value<const VkAttachmentStoreOp>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + 1, dump_text_VkAttachmentStoreOp);  // AET
    dump_text_value<const VkAttachmentLoadOp>(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + 1, dump_text_VkAttachmentLoadOp);  // AET
    dump_text_value<const VkAttachmentStoreOp>(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + 1, dump_text_VkAttachmentStoreOp);  // AET
    dump_text_value<const VkImageLayout>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + 1, dump_text_VkImageLayout);  // AET
}
void dump_text_VkAttachmentReference(const VkAttachmentReference& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.attachment, settings, "uint32_t", "attachment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageLayout>(object.layout, settings, "VkImageLayout", "layout", indents + 1, dump_text_VkImageLayout);  // AET
}
void dump_text_VkFramebufferCreateInfo(const VkFramebufferCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFramebufferCreateFlags>(object.flags, settings, "VkFramebufferCreateFlags", "flags", indents + 1, dump_text_VkFramebufferCreateFlags);  // AET
    dump_text_value<const VkRenderPass>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + 1, dump_text_VkRenderPass);  // AET
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageView>(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "const VkImageView", "pAttachments", indents + 1, dump_text_VkImageView); // BQB
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.layers, settings, "uint32_t", "layers", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassDescription(const VkSubpassDescription& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkSubpassDescriptionFlags>(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + 1, dump_text_VkSubpassDescriptionFlags);  // AET
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const uint32_t>(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentReference>(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference*", "const VkAttachmentReference", "pInputAttachments", indents + 1, dump_text_VkAttachmentReference); // BQB
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentReference>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "const VkAttachmentReference", "pColorAttachments", indents + 1, dump_text_VkAttachmentReference); // BQB
    dump_text_array<const VkAttachmentReference>(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "const VkAttachmentReference", "pResolveAttachments", indents + 1, dump_text_VkAttachmentReference); // BQB
    dump_text_pointer<const VkAttachmentReference>(object.pDepthStencilAttachment, settings, "const VkAttachmentReference*", "pDepthStencilAttachment", indents + 1, dump_text_VkAttachmentReference);
    dump_text_value<const uint32_t>(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "const uint32_t", "pPreserveAttachments", indents + 1, dump_text_uint32_t); // BQB
}
void dump_text_VkSubpassDependency(const VkSubpassDependency& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipelineStageFlags>(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + 1, dump_text_VkPipelineStageFlags);  // AET
    dump_text_value<const VkPipelineStageFlags>(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + 1, dump_text_VkPipelineStageFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkDependencyFlags>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + 1, dump_text_VkDependencyFlags);  // AET
}
void dump_text_VkRenderPassCreateInfo(const VkRenderPassCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderPassCreateFlags>(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + 1, dump_text_VkRenderPassCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentDescription>(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription*", "const VkAttachmentDescription", "pAttachments", indents + 1, dump_text_VkAttachmentDescription); // BQB
    dump_text_value<const uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubpassDescription>(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription*", "const VkSubpassDescription", "pSubpasses", indents + 1, dump_text_VkSubpassDescription); // BQB
    dump_text_value<const uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubpassDependency>(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency*", "const VkSubpassDependency", "pDependencies", indents + 1, dump_text_VkSubpassDependency); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCommandPoolCreateFlags>(object.flags, settings, "VkCommandPoolCreateFlags", "flags", indents + 1, dump_text_VkCommandPoolCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCommandPool>(object.commandPool, settings, "VkCommandPool", "commandPool", indents + 1, dump_text_VkCommandPool);  // AET
    dump_text_value<const VkCommandBufferLevel>(object.level, settings, "VkCommandBufferLevel", "level", indents + 1, dump_text_VkCommandBufferLevel);  // AET
    dump_text_value<const uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderPass>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + 1, dump_text_VkRenderPass);  // AET
    dump_text_value<const uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFramebuffer>(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + 1, dump_text_VkFramebuffer);  // AET
    dump_text_value<const VkBool32>(object.occlusionQueryEnable, settings, "VkBool32", "occlusionQueryEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkQueryControlFlags>(object.queryFlags, settings, "VkQueryControlFlags", "queryFlags", indents + 1, dump_text_VkQueryControlFlags);  // AET
    dump_text_value<const VkQueryPipelineStatisticFlags>(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + 1, dump_text_VkQueryPipelineStatisticFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCommandBufferUsageFlags>(object.flags, settings, "VkCommandBufferUsageFlags", "flags", indents + 1, dump_text_VkCommandBufferUsageFlags);  // AET
    if(ApiDumpInstance::current().getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY)
    dump_text_pointer<const VkCommandBufferInheritanceInfo>(object.pInheritanceInfo, settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 1, dump_text_VkCommandBufferInheritanceInfo);
    else
        dump_text_special("UNUSED", settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferCopy(const VkBufferCopy& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkImageSubresourceLayers(const VkImageSubresourceLayers& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    dump_text_value<const uint32_t>(object.mipLevel, settings, "uint32_t", "mipLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkBufferImageCopy(const VkBufferImageCopy& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceSize>(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + 1, dump_text_VkExtent3D);  // AET
}
void dump_text_VkClearDepthStencilValue(const VkClearDepthStencilValue& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.depth, settings, "float", "depth", indents + 1, dump_text_float);  // AET
    dump_text_value<const uint32_t>(object.stencil, settings, "uint32_t", "stencil", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkClearAttachment(const VkClearAttachment& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    dump_text_value<const uint32_t>(object.colorAttachment, settings, "uint32_t", "colorAttachment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkClearValue>(object.clearValue, settings, "VkClearValue", "clearValue", indents + 1, dump_text_VkClearValue);  // AET
}
void dump_text_VkClearRect(const VkClearRect& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkRect2D>(object.rect, settings, "VkRect2D", "rect", indents + 1, dump_text_VkRect2D);  // AET
    dump_text_value<const uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkImageBlit(const VkImageBlit& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_array<const VkOffset3D>(object.srcOffsets, 2, settings, "VkOffset3D[2]", "VkOffset3D", "srcOffsets", indents + 1, dump_text_VkOffset3D); // AQA
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_array<const VkOffset3D>(object.dstOffsets, 2, settings, "VkOffset3D[2]", "VkOffset3D", "dstOffsets", indents + 1, dump_text_VkOffset3D); // AQA
}
void dump_text_VkImageCopy(const VkImageCopy& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
}
void dump_text_VkImageResolve(const VkImageResolve& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
}
void dump_text_VkRenderPassBeginInfo(const VkRenderPassBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderPass>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + 1, dump_text_VkRenderPass);  // AET
    dump_text_value<const VkFramebuffer>(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + 1, dump_text_VkFramebuffer);  // AET
    dump_text_value<const VkRect2D>(object.renderArea, settings, "VkRect2D", "renderArea", indents + 1, dump_text_VkRect2D);  // AET
    dump_text_value<const uint32_t>(object.clearValueCount, settings, "uint32_t", "clearValueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkClearValue>(object.pClearValues, object.clearValueCount, settings, "const VkClearValue*", "const VkClearValue", "pClearValues", indents + 1, dump_text_VkClearValue); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderStageFlags>(object.supportedStages, settings, "VkShaderStageFlags", "supportedStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkSubgroupFeatureFlags>(object.supportedOperations, settings, "VkSubgroupFeatureFlags", "supportedOperations", indents + 1, dump_text_VkSubgroupFeatureFlags);  // AET
    dump_text_value<const VkBool32>(object.quadOperationsInAllStages, settings, "VkBool32", "quadOperationsInAllStages", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindImageMemoryInfo(const VkBindImageMemoryInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.prefersDedicatedAllocation, settings, "VkBool32", "prefersDedicatedAllocation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.requiresDedicatedAllocation, settings, "VkBool32", "requiresDedicatedAllocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMemoryAllocateFlags>(object.flags, settings, "VkMemoryAllocateFlags", "flags", indents + 1, dump_text_VkMemoryAllocateFlags);  // AET
    dump_text_value<const uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.deviceRenderAreaCount, settings, "uint32_t", "deviceRenderAreaCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pDeviceRenderAreas, object.deviceRenderAreaCount, settings, "const VkRect2D*", "const VkRect2D", "pDeviceRenderAreas", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pWaitSemaphoreDeviceIndices, object.waitSemaphoreCount, settings, "const uint32_t*", "const uint32_t", "pWaitSemaphoreDeviceIndices", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pCommandBufferDeviceMasks, object.commandBufferCount, settings, "const uint32_t*", "const uint32_t", "pCommandBufferDeviceMasks", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pSignalSemaphoreDeviceIndices, object.signalSemaphoreCount, settings, "const uint32_t*", "const uint32_t", "pSignalSemaphoreDeviceIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.resourceDeviceIndex, settings, "uint32_t", "resourceDeviceIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.memoryDeviceIndex, settings, "uint32_t", "memoryDeviceIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "const uint32_t", "pDeviceIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "const uint32_t", "pDeviceIndices", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.splitInstanceBindRegionCount, settings, "uint32_t", "splitInstanceBindRegionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pSplitInstanceBindRegions, object.splitInstanceBindRegionCount, settings, "const VkRect2D*", "const VkRect2D", "pSplitInstanceBindRegions", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPhysicalDevice>(object.physicalDevices, object.physicalDeviceCount, settings, "VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]", "VkPhysicalDevice", "physicalDevices", indents + 1, dump_text_VkPhysicalDevice); // BQB
    dump_text_value<const VkBool32>(object.subsetAllocation, settings, "VkBool32", "subsetAllocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPhysicalDevice>(object.pPhysicalDevices, object.physicalDeviceCount, settings, "const VkPhysicalDevice*", "const VkPhysicalDevice", "pPhysicalDevices", indents + 1, dump_text_VkPhysicalDevice); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryRequirements2(const VkMemoryRequirements2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkMemoryRequirements>(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + 1, dump_text_VkMemoryRequirements);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSparseImageMemoryRequirements>(object.memoryRequirements, settings, "VkSparseImageMemoryRequirements", "memoryRequirements", indents + 1, dump_text_VkSparseImageMemoryRequirements);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPhysicalDeviceFeatures>(object.features, settings, "VkPhysicalDeviceFeatures", "features", indents + 1, dump_text_VkPhysicalDeviceFeatures);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPhysicalDeviceProperties>(object.properties, settings, "VkPhysicalDeviceProperties", "properties", indents + 1, dump_text_VkPhysicalDeviceProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFormatProperties2(const VkFormatProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormatProperties>(object.formatProperties, settings, "VkFormatProperties", "formatProperties", indents + 1, dump_text_VkFormatProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageFormatProperties2(const VkImageFormatProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageFormatProperties>(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + 1, dump_text_VkImageFormatProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkImageType>(object.type, settings, "VkImageType", "type", indents + 1, dump_text_VkImageType);  // AET
    dump_text_value<const VkImageTiling>(object.tiling, settings, "VkImageTiling", "tiling", indents + 1, dump_text_VkImageTiling);  // AET
    dump_text_value<const VkImageUsageFlags>(object.usage, settings, "VkImageUsageFlags", "usage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkImageCreateFlags>(object.flags, settings, "VkImageCreateFlags", "flags", indents + 1, dump_text_VkImageCreateFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyProperties2(const VkQueueFamilyProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkQueueFamilyProperties>(object.queueFamilyProperties, settings, "VkQueueFamilyProperties", "queueFamilyProperties", indents + 1, dump_text_VkQueueFamilyProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    ApiDumpInstance::current().setMemoryHeapCount(object.memoryProperties.memoryHeapCount);
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPhysicalDeviceMemoryProperties>(object.memoryProperties, settings, "VkPhysicalDeviceMemoryProperties", "memoryProperties", indents + 1, dump_text_VkPhysicalDeviceMemoryProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSparseImageFormatProperties>(object.properties, settings, "VkSparseImageFormatProperties", "properties", indents + 1, dump_text_VkSparseImageFormatProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkImageType>(object.type, settings, "VkImageType", "type", indents + 1, dump_text_VkImageType);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkImageUsageFlags>(object.usage, settings, "VkImageUsageFlags", "usage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkImageTiling>(object.tiling, settings, "VkImageTiling", "tiling", indents + 1, dump_text_VkImageTiling);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPointClippingBehavior>(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + 1, dump_text_VkPointClippingBehavior);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.inputAttachmentIndex, settings, "uint32_t", "inputAttachmentIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
}
void dump_text_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.aspectReferenceCount, settings, "uint32_t", "aspectReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkInputAttachmentAspectReference>(object.pAspectReferences, object.aspectReferenceCount, settings, "const VkInputAttachmentAspectReference*", "const VkInputAttachmentAspectReference", "pAspectReferences", indents + 1, dump_text_VkInputAttachmentAspectReference); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageUsageFlags>(object.usage, settings, "VkImageUsageFlags", "usage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkTessellationDomainOrigin>(object.domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", indents + 1, dump_text_VkTessellationDomainOrigin);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pViewMasks, object.subpassCount, settings, "const uint32_t*", "const uint32_t", "pViewMasks", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const int32_t>(object.pViewOffsets, object.dependencyCount, settings, "const int32_t*", "const int32_t", "pViewOffsets", indents + 1, dump_text_int32_t); // BQB
    dump_text_value<const uint32_t>(object.correlationMaskCount, settings, "uint32_t", "correlationMaskCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pCorrelationMasks, object.correlationMaskCount, settings, "const uint32_t*", "const uint32_t", "pCorrelationMasks", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.multiview, settings, "VkBool32", "multiview", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.variablePointers, settings, "VkBool32", "variablePointers", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceQueueInfo2(const VkDeviceQueueInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceQueueCreateFlags>(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + 1, dump_text_VkDeviceQueueCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.queueIndex, settings, "uint32_t", "queueIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkProtectedSubmitInfo(const VkProtectedSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.protectedSubmit, settings, "VkBool32", "protectedSubmit", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkSamplerYcbcrModelConversion>(object.ycbcrModel, settings, "VkSamplerYcbcrModelConversion", "ycbcrModel", indents + 1, dump_text_VkSamplerYcbcrModelConversion);  // AET
    dump_text_value<const VkSamplerYcbcrRange>(object.ycbcrRange, settings, "VkSamplerYcbcrRange", "ycbcrRange", indents + 1, dump_text_VkSamplerYcbcrRange);  // AET
    dump_text_value<const VkComponentMapping>(object.components, settings, "VkComponentMapping", "components", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkChromaLocation>(object.xChromaOffset, settings, "VkChromaLocation", "xChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.yChromaOffset, settings, "VkChromaLocation", "yChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkFilter>(object.chromaFilter, settings, "VkFilter", "chromaFilter", indents + 1, dump_text_VkFilter);  // AET
    dump_text_value<const VkBool32>(object.forceExplicitReconstruction, settings, "VkBool32", "forceExplicitReconstruction", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSamplerYcbcrConversion>(object.conversion, settings, "VkSamplerYcbcrConversion", "conversion", indents + 1, dump_text_VkSamplerYcbcrConversion);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageAspectFlagBits>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + 1, dump_text_VkImageAspectFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageAspectFlagBits>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + 1, dump_text_VkImageAspectFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.combinedImageSamplerDescriptorCount, settings, "uint32_t", "combinedImageSamplerDescriptorCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.dstBinding, settings, "uint32_t", "dstBinding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDescriptorType>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + 1, dump_text_VkDescriptorType);  // AET
    dump_text_value<const size_t>(object.offset, settings, "size_t", "offset", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.stride, settings, "size_t", "stride", indents + 1, dump_text_size_t);  // AET
}
void dump_text_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorUpdateTemplateCreateFlags>(object.flags, settings, "VkDescriptorUpdateTemplateCreateFlags", "flags", indents + 1, dump_text_VkDescriptorUpdateTemplateCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.descriptorUpdateEntryCount, settings, "uint32_t", "descriptorUpdateEntryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorUpdateTemplateEntry>(object.pDescriptorUpdateEntries, object.descriptorUpdateEntryCount, settings, "const VkDescriptorUpdateTemplateEntry*", "const VkDescriptorUpdateTemplateEntry", "pDescriptorUpdateEntries", indents + 1, dump_text_VkDescriptorUpdateTemplateEntry); // BQB
    dump_text_value<const VkDescriptorUpdateTemplateType>(object.templateType, settings, "VkDescriptorUpdateTemplateType", "templateType", indents + 1, dump_text_VkDescriptorUpdateTemplateType);  // AET
    dump_text_value<const VkDescriptorSetLayout>(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + 1, dump_text_VkDescriptorSetLayout);  // AET
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const VkPipelineLayout>(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.set, settings, "uint32_t", "set", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalMemoryProperties(const VkExternalMemoryProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkExternalMemoryFeatureFlags>(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlags", "externalMemoryFeatures", indents + 1, dump_text_VkExternalMemoryFeatureFlags);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlags>(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "exportFromImportedHandleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlags);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlags>(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "compatibleHandleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlags);  // AET
}
void dump_text_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalImageFormatProperties(const VkExternalImageFormatProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExternalMemoryProperties>(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + 1, dump_text_VkExternalMemoryProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCreateFlags>(object.flags, settings, "VkBufferCreateFlags", "flags", indents + 1, dump_text_VkBufferCreateFlags);  // AET
    dump_text_value<const VkBufferUsageFlags>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + 1, dump_text_VkBufferUsageFlags);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalBufferProperties(const VkExternalBufferProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExternalMemoryProperties>(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + 1, dump_text_VkExternalMemoryProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint8_t>(object.deviceUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "deviceUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_array<const uint8_t>(object.driverUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "driverUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_array<const uint8_t>(object.deviceLUID, 8, settings, "uint8_t[VK_LUID_SIZE]", "uint8_t", "deviceLUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const uint32_t>(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlags>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlags>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlags>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalFenceHandleTypeFlagBits>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalFenceHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalFenceProperties(const VkExternalFenceProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExternalFenceHandleTypeFlags>(object.exportFromImportedHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "exportFromImportedHandleTypes", indents + 1, dump_text_VkExternalFenceHandleTypeFlags);  // AET
    dump_text_value<const VkExternalFenceHandleTypeFlags>(object.compatibleHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "compatibleHandleTypes", indents + 1, dump_text_VkExternalFenceHandleTypeFlags);  // AET
    dump_text_value<const VkExternalFenceFeatureFlags>(object.externalFenceFeatures, settings, "VkExternalFenceFeatureFlags", "externalFenceFeatures", indents + 1, dump_text_VkExternalFenceFeatureFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExportFenceCreateInfo(const VkExportFenceCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalFenceHandleTypeFlags>(object.handleTypes, settings, "VkExternalFenceHandleTypeFlags", "handleTypes", indents + 1, dump_text_VkExternalFenceHandleTypeFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalSemaphoreHandleTypeFlags>(object.handleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "handleTypes", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExternalSemaphoreHandleTypeFlags>(object.exportFromImportedHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "exportFromImportedHandleTypes", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlags);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlags>(object.compatibleHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "compatibleHandleTypes", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlags);  // AET
    dump_text_value<const VkExternalSemaphoreFeatureFlags>(object.externalSemaphoreFeatures, settings, "VkExternalSemaphoreFeatureFlags", "externalSemaphoreFeatures", indents + 1, dump_text_VkExternalSemaphoreFeatureFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.supported, settings, "VkBool32", "supported", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiview, settings, "VkBool32", "multiview", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.variablePointers, settings, "VkBool32", "variablePointers", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint8_t>(object.deviceUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "deviceUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_array<const uint8_t>(object.driverUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "driverUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_array<const uint8_t>(object.deviceLUID, 8, settings, "uint8_t[VK_LUID_SIZE]", "uint8_t", "deviceLUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const uint32_t>(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderStageFlags>(object.subgroupSupportedStages, settings, "VkShaderStageFlags", "subgroupSupportedStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkSubgroupFeatureFlags>(object.subgroupSupportedOperations, settings, "VkSubgroupFeatureFlags", "subgroupSupportedOperations", indents + 1, dump_text_VkSubgroupFeatureFlags);  // AET
    dump_text_value<const VkBool32>(object.subgroupQuadOperationsInAllStages, settings, "VkBool32", "subgroupQuadOperationsInAllStages", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkPointClippingBehavior>(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + 1, dump_text_VkPointClippingBehavior);  // AET
    dump_text_value<const uint32_t>(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.samplerMirrorClampToEdge, settings, "VkBool32", "samplerMirrorClampToEdge", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.drawIndirectCount, settings, "VkBool32", "drawIndirectCount", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorIndexing, settings, "VkBool32", "descriptorIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.samplerFilterMinmax, settings, "VkBool32", "samplerFilterMinmax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderOutputViewportIndex, settings, "VkBool32", "shaderOutputViewportIndex", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderOutputLayer, settings, "VkBool32", "shaderOutputLayer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.subgroupBroadcastDynamicId, settings, "VkBool32", "subgroupBroadcastDynamicId", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkConformanceVersion(const VkConformanceVersion& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint8_t>(object.major, settings, "uint8_t", "major", indents + 1, dump_text_uint8_t);  // AET
    dump_text_value<const uint8_t>(object.minor, settings, "uint8_t", "minor", indents + 1, dump_text_uint8_t);  // AET
    dump_text_value<const uint8_t>(object.subminor, settings, "uint8_t", "subminor", indents + 1, dump_text_uint8_t);  // AET
    dump_text_value<const uint8_t>(object.patch, settings, "uint8_t", "patch", indents + 1, dump_text_uint8_t);  // AET
}
void dump_text_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDriverId>(object.driverID, settings, "VkDriverId", "driverID", indents + 1, dump_text_VkDriverId);  // AET
    dump_text_value<const char*>(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkConformanceVersion>(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + 1, dump_text_VkConformanceVersion);  // AET
    dump_text_value<const VkShaderFloatControlsIndependence>(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + 1, dump_text_VkShaderFloatControlsIndependence);  // AET
    dump_text_value<const VkShaderFloatControlsIndependence>(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + 1, dump_text_VkShaderFloatControlsIndependence);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkResolveModeFlags>(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + 1, dump_text_VkResolveModeFlags);  // AET
    dump_text_value<const VkResolveModeFlags>(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + 1, dump_text_VkResolveModeFlags);  // AET
    dump_text_value<const VkBool32>(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.independentResolve, settings, "VkBool32", "independentResolve", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint64_t>(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkSampleCountFlags>(object.framebufferIntegerColorSampleCounts, settings, "VkSampleCountFlags", "framebufferIntegerColorSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFormat>(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "const VkFormat", "pViewFormats", indents + 1, dump_text_VkFormat); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentDescription2(const VkAttachmentDescription2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAttachmentDescriptionFlags>(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + 1, dump_text_VkAttachmentDescriptionFlags);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkAttachmentLoadOp>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + 1, dump_text_VkAttachmentLoadOp);  // AET
    dump_text_value<const VkAttachmentStoreOp>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + 1, dump_text_VkAttachmentStoreOp);  // AET
    dump_text_value<const VkAttachmentLoadOp>(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + 1, dump_text_VkAttachmentLoadOp);  // AET
    dump_text_value<const VkAttachmentStoreOp>(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + 1, dump_text_VkAttachmentStoreOp);  // AET
    dump_text_value<const VkImageLayout>(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + 1, dump_text_VkImageLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentReference2(const VkAttachmentReference2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.attachment, settings, "uint32_t", "attachment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageLayout>(object.layout, settings, "VkImageLayout", "layout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageAspectFlags>(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + 1, dump_text_VkImageAspectFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassDescription2(const VkSubpassDescription2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSubpassDescriptionFlags>(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + 1, dump_text_VkSubpassDescriptionFlags);  // AET
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentReference2>(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference2*", "const VkAttachmentReference2", "pInputAttachments", indents + 1, dump_text_VkAttachmentReference2); // BQB
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentReference2>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "const VkAttachmentReference2", "pColorAttachments", indents + 1, dump_text_VkAttachmentReference2); // BQB
    dump_text_array<const VkAttachmentReference2>(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "const VkAttachmentReference2", "pResolveAttachments", indents + 1, dump_text_VkAttachmentReference2); // BQB
    dump_text_pointer<const VkAttachmentReference2>(object.pDepthStencilAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilAttachment", indents + 1, dump_text_VkAttachmentReference2);
    dump_text_value<const uint32_t>(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "const uint32_t", "pPreserveAttachments", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassDependency2(const VkSubpassDependency2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipelineStageFlags>(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + 1, dump_text_VkPipelineStageFlags);  // AET
    dump_text_value<const VkPipelineStageFlags>(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + 1, dump_text_VkPipelineStageFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkAccessFlags>(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + 1, dump_text_VkAccessFlags);  // AET
    dump_text_value<const VkDependencyFlags>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + 1, dump_text_VkDependencyFlags);  // AET
    dump_text_value<const int32_t>(object.viewOffset, settings, "int32_t", "viewOffset", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderPassCreateFlags>(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + 1, dump_text_VkRenderPassCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentDescription2>(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription2*", "const VkAttachmentDescription2", "pAttachments", indents + 1, dump_text_VkAttachmentDescription2); // BQB
    dump_text_value<const uint32_t>(object.subpassCount, settings, "uint32_t", "subpassCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubpassDescription2>(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription2*", "const VkSubpassDescription2", "pSubpasses", indents + 1, dump_text_VkSubpassDescription2); // BQB
    dump_text_value<const uint32_t>(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubpassDependency2>(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency2*", "const VkSubpassDependency2", "pDependencies", indents + 1, dump_text_VkSubpassDependency2); // BQB
    dump_text_value<const uint32_t>(object.correlatedViewMaskCount, settings, "uint32_t", "correlatedViewMaskCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pCorrelatedViewMasks, object.correlatedViewMaskCount, settings, "const uint32_t*", "const uint32_t", "pCorrelatedViewMasks", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassBeginInfo(const VkSubpassBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSubpassContents>(object.contents, settings, "VkSubpassContents", "contents", indents + 1, dump_text_VkSubpassContents);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassEndInfo(const VkSubpassEndInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDriverId>(object.driverID, settings, "VkDriverId", "driverID", indents + 1, dump_text_VkDriverId);  // AET
    dump_text_value<const char*>(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkConformanceVersion>(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + 1, dump_text_VkConformanceVersion);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderFloatControlsIndependence>(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + 1, dump_text_VkShaderFloatControlsIndependence);  // AET
    dump_text_value<const VkShaderFloatControlsIndependence>(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + 1, dump_text_VkShaderFloatControlsIndependence);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.bindingCount, settings, "uint32_t", "bindingCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorBindingFlags>(object.pBindingFlags, object.bindingCount, settings, "const VkDescriptorBindingFlags*", "const VkDescriptorBindingFlags", "pBindingFlags", indents + 1, dump_text_VkDescriptorBindingFlags); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDescriptorCounts, object.descriptorSetCount, settings, "const uint32_t*", "const uint32_t", "pDescriptorCounts", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxVariableDescriptorCount, settings, "uint32_t", "maxVariableDescriptorCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkResolveModeFlagBits>(object.depthResolveMode, settings, "VkResolveModeFlagBits", "depthResolveMode", indents + 1, dump_text_VkResolveModeFlagBits);  // AET
    dump_text_value<const VkResolveModeFlagBits>(object.stencilResolveMode, settings, "VkResolveModeFlagBits", "stencilResolveMode", indents + 1, dump_text_VkResolveModeFlagBits);  // AET
    dump_text_pointer<const VkAttachmentReference2>(object.pDepthStencilResolveAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilResolveAttachment", indents + 1, dump_text_VkAttachmentReference2);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkResolveModeFlags>(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + 1, dump_text_VkResolveModeFlags);  // AET
    dump_text_value<const VkResolveModeFlags>(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + 1, dump_text_VkResolveModeFlags);  // AET
    dump_text_value<const VkBool32>(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.independentResolve, settings, "VkBool32", "independentResolve", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageUsageFlags>(object.stencilUsage, settings, "VkImageUsageFlags", "stencilUsage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSamplerReductionMode>(object.reductionMode, settings, "VkSamplerReductionMode", "reductionMode", indents + 1, dump_text_VkSamplerReductionMode);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageCreateFlags>(object.flags, settings, "VkImageCreateFlags", "flags", indents + 1, dump_text_VkImageCreateFlags);  // AET
    dump_text_value<const VkImageUsageFlags>(object.usage, settings, "VkImageUsageFlags", "usage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFormat>(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "const VkFormat", "pViewFormats", indents + 1, dump_text_VkFormat); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.attachmentImageInfoCount, settings, "uint32_t", "attachmentImageInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFramebufferAttachmentImageInfo>(object.pAttachmentImageInfos, object.attachmentImageInfoCount, settings, "const VkFramebufferAttachmentImageInfo*", "const VkFramebufferAttachmentImageInfo", "pAttachmentImageInfos", indents + 1, dump_text_VkFramebufferAttachmentImageInfo); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageView>(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "const VkImageView", "pAttachments", indents + 1, dump_text_VkImageView); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageLayout>(object.stencilLayout, settings, "VkImageLayout", "stencilLayout", indents + 1, dump_text_VkImageLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageLayout>(object.stencilInitialLayout, settings, "VkImageLayout", "stencilInitialLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.stencilFinalLayout, settings, "VkImageLayout", "stencilFinalLayout", indents + 1, dump_text_VkImageLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphoreType>(object.semaphoreType, settings, "VkSemaphoreType", "semaphoreType", indents + 1, dump_text_VkSemaphoreType);  // AET
    dump_text_value<const uint64_t>(object.initialValue, settings, "uint64_t", "initialValue", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreValueCount, settings, "uint32_t", "waitSemaphoreValueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pWaitSemaphoreValues, object.waitSemaphoreValueCount, settings, "const uint64_t*", "const uint64_t", "pWaitSemaphoreValues", indents + 1, dump_text_uint64_t); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreValueCount, settings, "uint32_t", "signalSemaphoreValueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pSignalSemaphoreValues, object.signalSemaphoreValueCount, settings, "const uint64_t*", "const uint64_t", "pSignalSemaphoreValues", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphoreWaitFlags>(object.flags, settings, "VkSemaphoreWaitFlags", "flags", indents + 1, dump_text_VkSemaphoreWaitFlags);  // AET
    dump_text_value<const uint32_t>(object.semaphoreCount, settings, "uint32_t", "semaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pSemaphores, object.semaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    dump_text_array<const uint64_t>(object.pValues, object.semaphoreCount, settings, "const uint64_t*", "const uint64_t", "pValues", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const uint64_t>(object.value, settings, "uint64_t", "value", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.privateData, settings, "VkBool32", "privateData", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.synchronization2, settings, "VkBool32", "synchronization2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.maintenance4, settings, "VkBool32", "maintenance4", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderStageFlags>(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const uint32_t>(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxInlineUniformTotalSize, settings, "uint32_t", "maxInlineUniformTotalSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBool32>(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBool32>(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCreationFeedback(const VkPipelineCreationFeedback& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkPipelineCreationFeedbackFlags>(object.flags, settings, "VkPipelineCreationFeedbackFlags", "flags", indents + 1, dump_text_VkPipelineCreationFeedbackFlags);  // AET
    dump_text_value<const uint64_t>(object.duration, settings, "uint64_t", "duration", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkPipelineCreationFeedback>(object.pPipelineCreationFeedback, settings, "VkPipelineCreationFeedback*", "pPipelineCreationFeedback", indents + 1, dump_text_VkPipelineCreationFeedback);
    dump_text_value<const uint32_t>(object.pipelineStageCreationFeedbackCount, settings, "uint32_t", "pipelineStageCreationFeedbackCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineCreationFeedback>(object.pPipelineStageCreationFeedbacks, object.pipelineStageCreationFeedbackCount, settings, "VkPipelineCreationFeedback*", "VkPipelineCreationFeedback", "pPipelineStageCreationFeedbacks", indents + 1, dump_text_VkPipelineCreationFeedback); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const char*>(object.name, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "name", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.version, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "version", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkToolPurposeFlags>(object.purposes, settings, "VkToolPurposeFlags", "purposes", indents + 1, dump_text_VkToolPurposeFlags);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.layer, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layer", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.privateData, settings, "VkBool32", "privateData", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.privateDataSlotRequestCount, settings, "uint32_t", "privateDataSlotRequestCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPrivateDataSlotCreateFlags>(object.flags, settings, "VkPrivateDataSlotCreateFlags", "flags", indents + 1, dump_text_VkPrivateDataSlotCreateFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryBarrier2(const VkMemoryBarrier2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineStageFlags2>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    dump_text_value<const VkPipelineStageFlags2>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineStageFlags2>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    dump_text_value<const VkPipelineStageFlags2>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    dump_text_value<const uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageMemoryBarrier2(const VkImageMemoryBarrier2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineStageFlags2>(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    dump_text_value<const VkPipelineStageFlags2>(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const VkAccessFlags2>(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + 1, dump_text_VkAccessFlags2);  // AET
    dump_text_value<const VkImageLayout>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageSubresourceRange>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + 1, dump_text_VkImageSubresourceRange);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDependencyInfo(const VkDependencyInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDependencyFlags>(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + 1, dump_text_VkDependencyFlags);  // AET
    dump_text_value<const uint32_t>(object.memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMemoryBarrier2>(object.pMemoryBarriers, object.memoryBarrierCount, settings, "const VkMemoryBarrier2*", "const VkMemoryBarrier2", "pMemoryBarriers", indents + 1, dump_text_VkMemoryBarrier2); // BQB
    dump_text_value<const uint32_t>(object.bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBufferMemoryBarrier2>(object.pBufferMemoryBarriers, object.bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier2*", "const VkBufferMemoryBarrier2", "pBufferMemoryBarriers", indents + 1, dump_text_VkBufferMemoryBarrier2); // BQB
    dump_text_value<const uint32_t>(object.imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageMemoryBarrier2>(object.pImageMemoryBarriers, object.imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier2*", "const VkImageMemoryBarrier2", "pImageMemoryBarriers", indents + 1, dump_text_VkImageMemoryBarrier2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const uint64_t>(object.value, settings, "uint64_t", "value", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkPipelineStageFlags2>(object.stageMask, settings, "VkPipelineStageFlags2", "stageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const uint32_t>(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCommandBuffer>(object.commandBuffer, settings, "VkCommandBuffer", "commandBuffer", indents + 1, dump_text_VkCommandBuffer);  // AET
    dump_text_value<const uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubmitInfo2(const VkSubmitInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSubmitFlags>(object.flags, settings, "VkSubmitFlags", "flags", indents + 1, dump_text_VkSubmitFlags);  // AET
    dump_text_value<const uint32_t>(object.waitSemaphoreInfoCount, settings, "uint32_t", "waitSemaphoreInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphoreSubmitInfo>(object.pWaitSemaphoreInfos, object.waitSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "const VkSemaphoreSubmitInfo", "pWaitSemaphoreInfos", indents + 1, dump_text_VkSemaphoreSubmitInfo); // BQB
    dump_text_value<const uint32_t>(object.commandBufferInfoCount, settings, "uint32_t", "commandBufferInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkCommandBufferSubmitInfo>(object.pCommandBufferInfos, object.commandBufferInfoCount, settings, "const VkCommandBufferSubmitInfo*", "const VkCommandBufferSubmitInfo", "pCommandBufferInfos", indents + 1, dump_text_VkCommandBufferSubmitInfo); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreInfoCount, settings, "uint32_t", "signalSemaphoreInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphoreSubmitInfo>(object.pSignalSemaphoreInfos, object.signalSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "const VkSemaphoreSubmitInfo", "pSignalSemaphoreInfos", indents + 1, dump_text_VkSemaphoreSubmitInfo); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.synchronization2, settings, "VkBool32", "synchronization2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferCopy2(const VkBufferCopy2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyBufferInfo2(const VkCopyBufferInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkBuffer>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBufferCopy2>(object.pRegions, object.regionCount, settings, "const VkBufferCopy2*", "const VkBufferCopy2", "pRegions", indents + 1, dump_text_VkBufferCopy2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageCopy2(const VkImageCopy2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyImageInfo2(const VkCopyImageInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageCopy2>(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "const VkImageCopy2", "pRegions", indents + 1, dump_text_VkImageCopy2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferImageCopy2(const VkBufferImageCopy2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + 1, dump_text_VkExtent3D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBufferImageCopy2>(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "const VkBufferImageCopy2", "pRegions", indents + 1, dump_text_VkBufferImageCopy2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkBuffer>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBufferImageCopy2>(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "const VkBufferImageCopy2", "pRegions", indents + 1, dump_text_VkBufferImageCopy2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageBlit2(const VkImageBlit2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_array<const VkOffset3D>(object.srcOffsets, 2, settings, "VkOffset3D[2]", "VkOffset3D", "srcOffsets", indents + 1, dump_text_VkOffset3D); // AQA
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_array<const VkOffset3D>(object.dstOffsets, 2, settings, "VkOffset3D[2]", "VkOffset3D", "dstOffsets", indents + 1, dump_text_VkOffset3D); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBlitImageInfo2(const VkBlitImageInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageBlit2>(object.pRegions, object.regionCount, settings, "const VkImageBlit2*", "const VkImageBlit2", "pRegions", indents + 1, dump_text_VkImageBlit2); // BQB
    dump_text_value<const VkFilter>(object.filter, settings, "VkFilter", "filter", indents + 1, dump_text_VkFilter);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageResolve2(const VkImageResolve2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageSubresourceLayers>(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.extent, settings, "VkExtent3D", "extent", indents + 1, dump_text_VkExtent3D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkResolveImageInfo2(const VkResolveImageInfo2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageResolve2>(object.pRegions, object.regionCount, settings, "const VkImageResolve2*", "const VkImageResolve2", "pRegions", indents + 1, dump_text_VkImageResolve2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderStageFlags>(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.requiredSubgroupSize, settings, "uint32_t", "requiredSubgroupSize", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.dataSize, settings, "uint32_t", "dataSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "const void*", "pData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxInlineUniformBlockBindings, settings, "uint32_t", "maxInlineUniformBlockBindings", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkImageLayout>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkResolveModeFlagBits>(object.resolveMode, settings, "VkResolveModeFlagBits", "resolveMode", indents + 1, dump_text_VkResolveModeFlagBits);  // AET
    dump_text_value<const VkImageView>(object.resolveImageView, settings, "VkImageView", "resolveImageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkImageLayout>(object.resolveImageLayout, settings, "VkImageLayout", "resolveImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkAttachmentLoadOp>(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + 1, dump_text_VkAttachmentLoadOp);  // AET
    dump_text_value<const VkAttachmentStoreOp>(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + 1, dump_text_VkAttachmentStoreOp);  // AET
    dump_text_value<const VkClearValue>(object.clearValue, settings, "VkClearValue", "clearValue", indents + 1, dump_text_VkClearValue);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingInfo(const VkRenderingInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderingFlags>(object.flags, settings, "VkRenderingFlags", "flags", indents + 1, dump_text_VkRenderingFlags);  // AET
    dump_text_value<const VkRect2D>(object.renderArea, settings, "VkRect2D", "renderArea", indents + 1, dump_text_VkRect2D);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRenderingAttachmentInfo>(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkRenderingAttachmentInfo*", "const VkRenderingAttachmentInfo", "pColorAttachments", indents + 1, dump_text_VkRenderingAttachmentInfo); // BQB
    dump_text_pointer<const VkRenderingAttachmentInfo>(object.pDepthAttachment, settings, "const VkRenderingAttachmentInfo*", "pDepthAttachment", indents + 1, dump_text_VkRenderingAttachmentInfo);
    dump_text_pointer<const VkRenderingAttachmentInfo>(object.pStencilAttachment, settings, "const VkRenderingAttachmentInfo*", "pStencilAttachment", indents + 1, dump_text_VkRenderingAttachmentInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    if(!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader())
    dump_text_array<const VkFormat>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "const VkFormat", "pColorAttachmentFormats", indents + 1, dump_text_VkFormat); // BQB
    else
        dump_text_special("UNUSED", settings, "const VkFormat*", "pColorAttachmentFormats", indents + 1);
    if(!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader())
    dump_text_value<const VkFormat>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    else
        dump_text_special("UNUSED", settings, "VkFormat", "depthAttachmentFormat", indents + 1);
    if(!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader())
    dump_text_value<const VkFormat>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    else
        dump_text_special("UNUSED", settings, "VkFormat", "stencilAttachmentFormat", indents + 1);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRenderingFlags>(object.flags, settings, "VkRenderingFlags", "flags", indents + 1, dump_text_VkRenderingFlags);  // AET
    dump_text_value<const uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFormat>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "const VkFormat", "pColorAttachmentFormats", indents + 1, dump_text_VkFormat); // BQB
    dump_text_value<const VkFormat>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkFormat>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBool32>(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBool32>(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFormatProperties3(const VkFormatProperties3& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormatFeatureFlags2>(object.linearTilingFeatures, settings, "VkFormatFeatureFlags2", "linearTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags2);  // AET
    dump_text_value<const VkFormatFeatureFlags2>(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags2", "optimalTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags2);  // AET
    dump_text_value<const VkFormatFeatureFlags2>(object.bufferFeatures, settings, "VkFormatFeatureFlags2", "bufferFeatures", indents + 1, dump_text_VkFormatFeatureFlags2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.maintenance4, settings, "VkBool32", "maintenance4", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkBufferCreateInfo>(object.pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", indents + 1, dump_text_VkBufferCreateInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkImageCreateInfo>(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + 1, dump_text_VkImageCreateInfo);
    dump_text_value<const VkImageAspectFlagBits>(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + 1, dump_text_VkImageAspectFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.smoothLines, settings, "VkBool32", "smoothLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.maintenance5, settings, "VkBool32", "maintenance5", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.maintenance6, settings, "VkBool32", "maintenance6", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pushDescriptor, settings, "VkBool32", "pushDescriptor", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVulkan14Properties(const VkPhysicalDeviceVulkan14Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.dynamicRenderingLocalReadDepthStencilAttachments, settings, "VkBool32", "dynamicRenderingLocalReadDepthStencilAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dynamicRenderingLocalReadMultisampledAttachments, settings, "VkBool32", "dynamicRenderingLocalReadMultisampledAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessImageBehavior>(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + 1, dump_text_VkPipelineRobustnessImageBehavior);  // AET
    dump_text_value<const uint32_t>(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageLayout>(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "VkImageLayout", "pCopySrcLayouts", indents + 1, dump_text_VkImageLayout); // BQB
    dump_text_value<const uint32_t>(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageLayout>(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "VkImageLayout", "pCopyDstLayouts", indents + 1, dump_text_VkImageLayout); // BQB
    dump_text_array<const uint8_t>(object.optimalTilingLayoutUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "optimalTilingLayoutUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const VkBool32>(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceQueueGlobalPriorityCreateInfo(const VkDeviceQueueGlobalPriorityCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueueGlobalPriority>(object.globalPriority, settings, "VkQueueGlobalPriority", "globalPriority", indents + 1, dump_text_VkQueueGlobalPriority);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceGlobalPriorityQueryFeatures(const VkPhysicalDeviceGlobalPriorityQueryFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.priorityCount, settings, "uint32_t", "priorityCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkQueueGlobalPriority>(object.priorities, 16, settings, "VkQueueGlobalPriority[VK_MAX_GLOBAL_PRIORITY_SIZE]", "VkQueueGlobalPriority", "priorities", indents + 1, dump_text_VkQueueGlobalPriority); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderSubgroupRotateFeatures(const VkPhysicalDeviceShaderSubgroupRotateFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderFloatControls2Features(const VkPhysicalDeviceShaderFloatControls2Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderExpectAssumeFeatures(const VkPhysicalDeviceShaderExpectAssumeFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLineRasterizationFeatures(const VkPhysicalDeviceLineRasterizationFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.smoothLines, settings, "VkBool32", "smoothLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLineRasterizationProperties(const VkPhysicalDeviceLineRasterizationProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationLineStateCreateInfo(const VkPipelineRasterizationLineStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkLineRasterizationMode>(object.lineRasterizationMode, settings, "VkLineRasterizationMode", "lineRasterizationMode", indents + 1, dump_text_VkLineRasterizationMode);  // AET
    dump_text_value<const VkBool32>(object.stippledLineEnable, settings, "VkBool32", "stippledLineEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.lineStippleFactor, settings, "uint32_t", "lineStippleFactor", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint16_t>(object.lineStipplePattern, settings, "uint16_t", "lineStipplePattern", indents + 1, dump_text_uint16_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVertexAttributeDivisorProperties(const VkPhysicalDeviceVertexAttributeDivisorProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVertexInputBindingDivisorDescription(const VkVertexInputBindingDivisorDescription& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.divisor, settings, "uint32_t", "divisor", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPipelineVertexInputDivisorStateCreateInfo(const VkPipelineVertexInputDivisorStateCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.vertexBindingDivisorCount, settings, "uint32_t", "vertexBindingDivisorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVertexInputBindingDivisorDescription>(object.pVertexBindingDivisors, object.vertexBindingDivisorCount, settings, "const VkVertexInputBindingDivisorDescription*", "const VkVertexInputBindingDivisorDescription", "pVertexBindingDivisors", indents + 1, dump_text_VkVertexInputBindingDivisorDescription); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVertexAttributeDivisorFeatures(const VkPhysicalDeviceVertexAttributeDivisorFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceIndexTypeUint8Features(const VkPhysicalDeviceIndexTypeUint8Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryMapInfo(const VkMemoryMapInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMemoryMapFlags>(object.flags, settings, "VkMemoryMapFlags", "flags", indents + 1, dump_text_VkMemoryMapFlags);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryUnmapInfo(const VkMemoryUnmapInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMemoryUnmapFlags>(object.flags, settings, "VkMemoryUnmapFlags", "flags", indents + 1, dump_text_VkMemoryUnmapFlags);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance5Features(const VkPhysicalDeviceMaintenance5Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.maintenance5, settings, "VkBool32", "maintenance5", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance5Properties(const VkPhysicalDeviceMaintenance5Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingAreaInfo(const VkRenderingAreaInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.viewMask, settings, "uint32_t", "viewMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFormat>(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "const VkFormat", "pColorAttachmentFormats", indents + 1, dump_text_VkFormat); // BQB
    dump_text_value<const VkFormat>(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkFormat>(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageSubresource2(const VkImageSubresource2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageSubresource>(object.imageSubresource, settings, "VkImageSubresource", "imageSubresource", indents + 1, dump_text_VkImageSubresource);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkImageCreateInfo>(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + 1, dump_text_VkImageCreateInfo);
    dump_text_pointer<const VkImageSubresource2>(object.pSubresource, settings, "const VkImageSubresource2*", "pSubresource", indents + 1, dump_text_VkImageSubresource2);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubresourceLayout2(const VkSubresourceLayout2& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSubresourceLayout>(object.subresourceLayout, settings, "VkSubresourceLayout", "subresourceLayout", indents + 1, dump_text_VkSubresourceLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags2>(object.flags, settings, "VkPipelineCreateFlags2", "flags", indents + 1, dump_text_VkPipelineCreateFlags2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferUsageFlags2>(object.usage, settings, "VkBufferUsageFlags2", "usage", indents + 1, dump_text_VkBufferUsageFlags2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePushDescriptorProperties(const VkPhysicalDevicePushDescriptorProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pColorAttachmentLocations, object.colorAttachmentCount, settings, "const uint32_t*", "const uint32_t", "pColorAttachmentLocations", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingInputAttachmentIndexInfo(const VkRenderingInputAttachmentIndexInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pColorAttachmentInputIndices, object.colorAttachmentCount, settings, "const uint32_t*", "const uint32_t", "pColorAttachmentInputIndices", indents + 1, dump_text_uint32_t); // BQB
    dump_text_pointer<const uint32_t>(object.pDepthInputAttachmentIndex, settings, "const uint32_t*", "pDepthInputAttachmentIndex", indents + 1, dump_text_uint32_t);
    dump_text_pointer<const uint32_t>(object.pStencilInputAttachmentIndex, settings, "const uint32_t*", "pStencilInputAttachmentIndex", indents + 1, dump_text_uint32_t);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance6Features(const VkPhysicalDeviceMaintenance6Features& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.maintenance6, settings, "VkBool32", "maintenance6", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance6Properties(const VkPhysicalDeviceMaintenance6Properties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindMemoryStatus(const VkBindMemoryStatus& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkResult>(object.pResult, settings, "VkResult*", "pResult", indents + 1, dump_text_VkResult);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.firstSet, settings, "uint32_t", "firstSet", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSet>(object.pDescriptorSets, object.descriptorSetCount, settings, "const VkDescriptorSet*", "const VkDescriptorSet", "pDescriptorSets", indents + 1, dump_text_VkDescriptorSet); // BQB
    dump_text_value<const uint32_t>(object.dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDynamicOffsets, object.dynamicOffsetCount, settings, "const uint32_t*", "const uint32_t", "pDynamicOffsets", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPushConstantsInfo(const VkPushConstantsInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pValues, settings, "const void*", "pValues", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.set, settings, "uint32_t", "set", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkWriteDescriptorSet>(object.pDescriptorWrites, object.descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "const VkWriteDescriptorSet", "pDescriptorWrites", indents + 1, dump_text_VkWriteDescriptorSet); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPushDescriptorSetWithTemplateInfo(const VkPushDescriptorSetWithTemplateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorUpdateTemplate>(object.descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", indents + 1, dump_text_VkDescriptorUpdateTemplate);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.set, settings, "uint32_t", "set", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "const void*", "pData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineProtectedAccessFeatures(const VkPhysicalDevicePipelineProtectedAccessFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineRobustnessFeatures(const VkPhysicalDevicePipelineRobustnessFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineRobustnessProperties(const VkPhysicalDevicePipelineRobustnessProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessImageBehavior>(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + 1, dump_text_VkPipelineRobustnessImageBehavior);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.storageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "storageBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.uniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "uniformBuffers", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessBufferBehavior>(object.vertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "vertexInputs", indents + 1, dump_text_VkPipelineRobustnessBufferBehavior);  // AET
    dump_text_value<const VkPipelineRobustnessImageBehavior>(object.images, settings, "VkPipelineRobustnessImageBehavior", "images", indents + 1, dump_text_VkPipelineRobustnessImageBehavior);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceHostImageCopyFeatures(const VkPhysicalDeviceHostImageCopyFeatures& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceHostImageCopyProperties(const VkPhysicalDeviceHostImageCopyProperties& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageLayout>(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "VkImageLayout", "pCopySrcLayouts", indents + 1, dump_text_VkImageLayout); // BQB
    dump_text_value<const uint32_t>(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageLayout>(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "VkImageLayout", "pCopyDstLayouts", indents + 1, dump_text_VkImageLayout); // BQB
    dump_text_array<const uint8_t>(object.optimalTilingLayoutUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "optimalTilingLayoutUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const VkBool32>(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryToImageCopy(const VkMemoryToImageCopy& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.pHostPointer, settings, "const void*", "pHostPointer", indents + 1, dump_text_void);  // AET
    dump_text_value<const uint32_t>(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + 1, dump_text_VkExtent3D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageToMemoryCopy(const VkImageToMemoryCopy& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.pHostPointer, settings, "void*", "pHostPointer", indents + 1, dump_text_void);  // AET
    dump_text_value<const uint32_t>(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + 1, dump_text_VkExtent3D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkHostImageCopyFlags>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + 1, dump_text_VkHostImageCopyFlags);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMemoryToImageCopy>(object.pRegions, object.regionCount, settings, "const VkMemoryToImageCopy*", "const VkMemoryToImageCopy", "pRegions", indents + 1, dump_text_VkMemoryToImageCopy); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkHostImageCopyFlags>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + 1, dump_text_VkHostImageCopyFlags);  // AET
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageToMemoryCopy>(object.pRegions, object.regionCount, settings, "const VkImageToMemoryCopy*", "const VkImageToMemoryCopy", "pRegions", indents + 1, dump_text_VkImageToMemoryCopy); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyImageToImageInfo(const VkCopyImageToImageInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkHostImageCopyFlags>(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + 1, dump_text_VkHostImageCopyFlags);  // AET
    dump_text_value<const VkImage>(object.srcImage, settings, "VkImage", "srcImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImage>(object.dstImage, settings, "VkImage", "dstImage", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageCopy2>(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "const VkImageCopy2", "pRegions", indents + 1, dump_text_VkImageCopy2); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageLayout>(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageLayout>(object.newLayout, settings, "VkImageLayout", "newLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkImageSubresourceRange>(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + 1, dump_text_VkImageSubresourceRange);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkHostImageCopyDevicePerformanceQuery(const VkHostImageCopyDevicePerformanceQuery& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.optimalDeviceAccess, settings, "VkBool32", "optimalDeviceAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.identicalMemoryLayout, settings, "VkBool32", "identicalMemoryLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent2D>(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSurfaceTransformFlagsKHR>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + 1, dump_text_VkSurfaceTransformFlagsKHR);  // AET
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    dump_text_value<const VkCompositeAlphaFlagsKHR>(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + 1, dump_text_VkCompositeAlphaFlagsKHR);  // AET
    dump_text_value<const VkImageUsageFlags>(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + 1, dump_text_VkImageUsageFlags);  // AET
}
void dump_text_VkSurfaceFormatKHR(const VkSurfaceFormatKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkColorSpaceKHR>(object.colorSpace, settings, "VkColorSpaceKHR", "colorSpace", indents + 1, dump_text_VkColorSpaceKHR);  // AET
}
void dump_text_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSwapchainCreateFlagsKHR>(object.flags, settings, "VkSwapchainCreateFlagsKHR", "flags", indents + 1, dump_text_VkSwapchainCreateFlagsKHR);  // AET
    dump_text_value<const VkSurfaceKHR>(object.surface, settings, "VkSurfaceKHR", "surface", indents + 1, dump_text_VkSurfaceKHR);  // AET
    dump_text_value<const uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormat>(object.imageFormat, settings, "VkFormat", "imageFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkColorSpaceKHR>(object.imageColorSpace, settings, "VkColorSpaceKHR", "imageColorSpace", indents + 1, dump_text_VkColorSpaceKHR);  // AET
    dump_text_value<const VkExtent2D>(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.imageArrayLayers, settings, "uint32_t", "imageArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageUsageFlags>(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkSharingMode>(object.imageSharingMode, settings, "VkSharingMode", "imageSharingMode", indents + 1, dump_text_VkSharingMode);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.imageSharingMode == VK_SHARING_MODE_CONCURRENT)
    dump_text_array<const uint32_t>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "const uint32_t", "pQueueFamilyIndices", indents + 1, dump_text_uint32_t); // BQB
    else
        dump_text_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1);
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.preTransform, settings, "VkSurfaceTransformFlagBitsKHR", "preTransform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    dump_text_value<const VkCompositeAlphaFlagBitsKHR>(object.compositeAlpha, settings, "VkCompositeAlphaFlagBitsKHR", "compositeAlpha", indents + 1, dump_text_VkCompositeAlphaFlagBitsKHR);  // AET
    dump_text_value<const VkPresentModeKHR>(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + 1, dump_text_VkPresentModeKHR);  // AET
    dump_text_value<const VkBool32>(object.clipped, settings, "VkBool32", "clipped", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkSwapchainKHR>(object.oldSwapchain, settings, "VkSwapchainKHR", "oldSwapchain", indents + 1, dump_text_VkSwapchainKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPresentInfoKHR(const VkPresentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphore>(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "const VkSemaphore", "pWaitSemaphores", indents + 1, dump_text_VkSemaphore); // BQB
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSwapchainKHR>(object.pSwapchains, object.swapchainCount, settings, "const VkSwapchainKHR*", "const VkSwapchainKHR", "pSwapchains", indents + 1, dump_text_VkSwapchainKHR); // BQB
    dump_text_array<const uint32_t>(object.pImageIndices, object.swapchainCount, settings, "const uint32_t*", "const uint32_t", "pImageIndices", indents + 1, dump_text_uint32_t); // BQB
    dump_text_array<const VkResult>(object.pResults, object.swapchainCount, settings, "VkResult*", "VkResult", "pResults", indents + 1, dump_text_VkResult); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSwapchainKHR>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + 1, dump_text_VkSwapchainKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSwapchainKHR>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + 1, dump_text_VkSwapchainKHR);  // AET
    dump_text_value<const uint32_t>(object.imageIndex, settings, "uint32_t", "imageIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSwapchainKHR>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + 1, dump_text_VkSwapchainKHR);  // AET
    dump_text_value<const uint64_t>(object.timeout, settings, "uint64_t", "timeout", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkFence>(object.fence, settings, "VkFence", "fence", indents + 1, dump_text_VkFence);  // AET
    dump_text_value<const uint32_t>(object.deviceMask, settings, "uint32_t", "deviceMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint32_t>(object.presentMask, 32, settings, "uint32_t[VK_MAX_DEVICE_GROUP_SIZE]", "uint32_t", "presentMask", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const VkDeviceGroupPresentModeFlagsKHR>(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + 1, dump_text_VkDeviceGroupPresentModeFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDeviceMasks, object.swapchainCount, settings, "const uint32_t*", "const uint32_t", "pDeviceMasks", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const VkDeviceGroupPresentModeFlagBitsKHR>(object.mode, settings, "VkDeviceGroupPresentModeFlagBitsKHR", "mode", indents + 1, dump_text_VkDeviceGroupPresentModeFlagBitsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceGroupPresentModeFlagsKHR>(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + 1, dump_text_VkDeviceGroupPresentModeFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkExtent2D>(object.visibleRegion, settings, "VkExtent2D", "visibleRegion", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.refreshRate, settings, "uint32_t", "refreshRate", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplayModeCreateFlagsKHR>(object.flags, settings, "VkDisplayModeCreateFlagsKHR", "flags", indents + 1, dump_text_VkDisplayModeCreateFlagsKHR);  // AET
    dump_text_value<const VkDisplayModeParametersKHR>(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + 1, dump_text_VkDisplayModeParametersKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDisplayModeKHR>(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + 1, dump_text_VkDisplayModeKHR);  // AET
    dump_text_value<const VkDisplayModeParametersKHR>(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + 1, dump_text_VkDisplayModeParametersKHR);  // AET
}
void dump_text_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDisplayPlaneAlphaFlagsKHR>(object.supportedAlpha, settings, "VkDisplayPlaneAlphaFlagsKHR", "supportedAlpha", indents + 1, dump_text_VkDisplayPlaneAlphaFlagsKHR);  // AET
    dump_text_value<const VkOffset2D>(object.minSrcPosition, settings, "VkOffset2D", "minSrcPosition", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkOffset2D>(object.maxSrcPosition, settings, "VkOffset2D", "maxSrcPosition", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.minSrcExtent, settings, "VkExtent2D", "minSrcExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxSrcExtent, settings, "VkExtent2D", "maxSrcExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkOffset2D>(object.minDstPosition, settings, "VkOffset2D", "minDstPosition", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkOffset2D>(object.maxDstPosition, settings, "VkOffset2D", "maxDstPosition", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.minDstExtent, settings, "VkExtent2D", "minDstExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxDstExtent, settings, "VkExtent2D", "maxDstExtent", indents + 1, dump_text_VkExtent2D);  // AET
}
void dump_text_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDisplayKHR>(object.currentDisplay, settings, "VkDisplayKHR", "currentDisplay", indents + 1, dump_text_VkDisplayKHR);  // AET
    dump_text_value<const uint32_t>(object.currentStackIndex, settings, "uint32_t", "currentStackIndex", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDisplayKHR>(object.display, settings, "VkDisplayKHR", "display", indents + 1, dump_text_VkDisplayKHR);  // AET
    dump_text_value<const char*>(object.displayName, settings, "const char*", "displayName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkExtent2D>(object.physicalDimensions, settings, "VkExtent2D", "physicalDimensions", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.physicalResolution, settings, "VkExtent2D", "physicalResolution", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkSurfaceTransformFlagsKHR>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + 1, dump_text_VkSurfaceTransformFlagsKHR);  // AET
    dump_text_value<const VkBool32>(object.planeReorderPossible, settings, "VkBool32", "planeReorderPossible", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.persistentContent, settings, "VkBool32", "persistentContent", indents + 1, dump_text_VkBool32);  // AET
}
void dump_text_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplaySurfaceCreateFlagsKHR>(object.flags, settings, "VkDisplaySurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkDisplaySurfaceCreateFlagsKHR);  // AET
    dump_text_value<const VkDisplayModeKHR>(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + 1, dump_text_VkDisplayModeKHR);  // AET
    dump_text_value<const uint32_t>(object.planeIndex, settings, "uint32_t", "planeIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.planeStackIndex, settings, "uint32_t", "planeStackIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    dump_text_value<const float>(object.globalAlpha, settings, "float", "globalAlpha", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkDisplayPlaneAlphaFlagBitsKHR>(object.alphaMode, settings, "VkDisplayPlaneAlphaFlagBitsKHR", "alphaMode", indents + 1, dump_text_VkDisplayPlaneAlphaFlagBitsKHR);  // AET
    dump_text_value<const VkExtent2D>(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRect2D>(object.srcRect, settings, "VkRect2D", "srcRect", indents + 1, dump_text_VkRect2D);  // AET
    dump_text_value<const VkRect2D>(object.dstRect, settings, "VkRect2D", "dstRect", indents + 1, dump_text_VkRect2D);  // AET
    dump_text_value<const VkBool32>(object.persistent, settings, "VkBool32", "persistent", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkXlibSurfaceCreateFlagsKHR>(object.flags, settings, "VkXlibSurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkXlibSurfaceCreateFlagsKHR);  // AET
    dump_text_value<const Display*>(object.dpy, settings, "Display*", "dpy", indents + 1, dump_text_Display);  // AET
    dump_text_value<const Window>(object.window, settings, "Window", "window", indents + 1, dump_text_Window);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkXcbSurfaceCreateFlagsKHR>(object.flags, settings, "VkXcbSurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkXcbSurfaceCreateFlagsKHR);  // AET
    dump_text_value<const xcb_connection_t*>(object.connection, settings, "xcb_connection_t*", "connection", indents + 1, dump_text_xcb_connection_t);  // AET
    dump_text_value<const xcb_window_t>(object.window, settings, "xcb_window_t", "window", indents + 1, dump_text_xcb_window_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkWaylandSurfaceCreateFlagsKHR>(object.flags, settings, "VkWaylandSurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkWaylandSurfaceCreateFlagsKHR);  // AET
    dump_text_value<const wl_display*>(object.display, settings, "struct wl_display*", "display", indents + 1, dump_text_wl_display);  // AET
    dump_text_value<const wl_surface*>(object.surface, settings, "struct wl_surface*", "surface", indents + 1, dump_text_wl_surface);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAndroidSurfaceCreateFlagsKHR>(object.flags, settings, "VkAndroidSurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkAndroidSurfaceCreateFlagsKHR);  // AET
    dump_text_value<const ANativeWindow*>(object.window, settings, "struct ANativeWindow*", "window", indents + 1, dump_text_ANativeWindow);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkWin32SurfaceCreateFlagsKHR>(object.flags, settings, "VkWin32SurfaceCreateFlagsKHR", "flags", indents + 1, dump_text_VkWin32SurfaceCreateFlagsKHR);  // AET
    dump_text_value<const HINSTANCE>(object.hinstance, settings, "HINSTANCE", "hinstance", indents + 1, dump_text_HINSTANCE);  // AET
    dump_text_value<const HWND>(object.hwnd, settings, "HWND", "hwnd", indents + 1, dump_text_HWND);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDebugReportFlagsEXT>(object.flags, settings, "VkDebugReportFlagsEXT", "flags", indents + 1, dump_text_VkDebugReportFlagsEXT);  // AET
    dump_text_value<const PFN_vkDebugReportCallbackEXT>(object.pfnCallback, settings, "PFN_vkDebugReportCallbackEXT", "pfnCallback", indents + 1, dump_text_PFN_vkDebugReportCallbackEXT);  // AET
    dump_text_value<const void*>(object.pUserData, settings, "void*", "pUserData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRasterizationOrderAMD>(object.rasterizationOrder, settings, "VkRasterizationOrderAMD", "rasterizationOrder", indents + 1, dump_text_VkRasterizationOrderAMD);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDebugReportObjectTypeEXT>(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + 1, dump_text_VkDebugReportObjectTypeEXT);  // AET
    dump_text_value<const uint64_t>(object.object, settings, "uint64_t", "object", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const char*>(object.pObjectName, settings, "const char*", "pObjectName", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDebugReportObjectTypeEXT>(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + 1, dump_text_VkDebugReportObjectTypeEXT);  // AET
    dump_text_value<const uint64_t>(object.object, settings, "uint64_t", "object", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const size_t>(object.tagSize, settings, "size_t", "tagSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pTag, settings, "const void*", "pTag", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const char*>(object.pMarkerName, settings, "const char*", "pMarkerName", indents + 1, dump_text_cstring);  // AET
    dump_text_array<const float>(object.color, 4, settings, "float[4]", "float", "color", indents + 1, dump_text_float); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.queryResultStatusSupport, settings, "VkBool32", "queryResultStatusSupport", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoCodecOperationFlagsKHR>(object.videoCodecOperations, settings, "VkVideoCodecOperationFlagsKHR", "videoCodecOperations", indents + 1, dump_text_VkVideoCodecOperationFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoCodecOperationFlagBitsKHR>(object.videoCodecOperation, settings, "VkVideoCodecOperationFlagBitsKHR", "videoCodecOperation", indents + 1, dump_text_VkVideoCodecOperationFlagBitsKHR);  // AET
    dump_text_value<const VkVideoChromaSubsamplingFlagsKHR>(object.chromaSubsampling, settings, "VkVideoChromaSubsamplingFlagsKHR", "chromaSubsampling", indents + 1, dump_text_VkVideoChromaSubsamplingFlagsKHR);  // AET
    dump_text_value<const VkVideoComponentBitDepthFlagsKHR>(object.lumaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "lumaBitDepth", indents + 1, dump_text_VkVideoComponentBitDepthFlagsKHR);  // AET
    dump_text_value<const VkVideoComponentBitDepthFlagsKHR>(object.chromaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "chromaBitDepth", indents + 1, dump_text_VkVideoComponentBitDepthFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.profileCount, settings, "uint32_t", "profileCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoProfileInfoKHR>(object.pProfiles, object.profileCount, settings, "const VkVideoProfileInfoKHR*", "const VkVideoProfileInfoKHR", "pProfiles", indents + 1, dump_text_VkVideoProfileInfoKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoCapabilityFlagsKHR>(object.flags, settings, "VkVideoCapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoCapabilityFlagsKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.minBitstreamBufferOffsetAlignment, settings, "VkDeviceSize", "minBitstreamBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.minBitstreamBufferSizeAlignment, settings, "VkDeviceSize", "minBitstreamBufferSizeAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkExtent2D>(object.pictureAccessGranularity, settings, "VkExtent2D", "pictureAccessGranularity", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.minCodedExtent, settings, "VkExtent2D", "minCodedExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtensionProperties>(object.stdHeaderVersion, settings, "VkExtensionProperties", "stdHeaderVersion", indents + 1, dump_text_VkExtensionProperties);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageUsageFlags>(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + 1, dump_text_VkImageUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkComponentMapping>(object.componentMapping, settings, "VkComponentMapping", "componentMapping", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkImageCreateFlags>(object.imageCreateFlags, settings, "VkImageCreateFlags", "imageCreateFlags", indents + 1, dump_text_VkImageCreateFlags);  // AET
    dump_text_value<const VkImageType>(object.imageType, settings, "VkImageType", "imageType", indents + 1, dump_text_VkImageType);  // AET
    dump_text_value<const VkImageTiling>(object.imageTiling, settings, "VkImageTiling", "imageTiling", indents + 1, dump_text_VkImageTiling);  // AET
    dump_text_value<const VkImageUsageFlags>(object.imageUsageFlags, settings, "VkImageUsageFlags", "imageUsageFlags", indents + 1, dump_text_VkImageUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkOffset2D>(object.codedOffset, settings, "VkOffset2D", "codedOffset", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.codedExtent, settings, "VkExtent2D", "codedExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageView>(object.imageViewBinding, settings, "VkImageView", "imageViewBinding", indents + 1, dump_text_VkImageView);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const int32_t>(object.slotIndex, settings, "int32_t", "slotIndex", indents + 1, dump_text_int32_t);  // AET
    dump_text_pointer<const VkVideoPictureResourceInfoKHR>(object.pPictureResource, settings, "const VkVideoPictureResourceInfoKHR*", "pPictureResource", indents + 1, dump_text_VkVideoPictureResourceInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkMemoryRequirements>(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + 1, dump_text_VkMemoryRequirements);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.memorySize, settings, "VkDeviceSize", "memorySize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVideoSessionCreateFlagsKHR>(object.flags, settings, "VkVideoSessionCreateFlagsKHR", "flags", indents + 1, dump_text_VkVideoSessionCreateFlagsKHR);  // AET
    dump_text_pointer<const VkVideoProfileInfoKHR>(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + 1, dump_text_VkVideoProfileInfoKHR);
    dump_text_value<const VkFormat>(object.pictureFormat, settings, "VkFormat", "pictureFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkExtent2D>(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkFormat>(object.referencePictureFormat, settings, "VkFormat", "referencePictureFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint32_t>(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkExtensionProperties>(object.pStdHeaderVersion, settings, "const VkExtensionProperties*", "pStdHeaderVersion", indents + 1, dump_text_VkExtensionProperties);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoSessionParametersCreateFlagsKHR>(object.flags, settings, "VkVideoSessionParametersCreateFlagsKHR", "flags", indents + 1, dump_text_VkVideoSessionParametersCreateFlagsKHR);  // AET
    dump_text_value<const VkVideoSessionParametersKHR>(object.videoSessionParametersTemplate, settings, "VkVideoSessionParametersKHR", "videoSessionParametersTemplate", indents + 1, dump_text_VkVideoSessionParametersKHR);  // AET
    dump_text_value<const VkVideoSessionKHR>(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + 1, dump_text_VkVideoSessionKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.updateSequenceCount, settings, "uint32_t", "updateSequenceCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoBeginCodingFlagsKHR>(object.flags, settings, "VkVideoBeginCodingFlagsKHR", "flags", indents + 1, dump_text_VkVideoBeginCodingFlagsKHR);  // AET
    dump_text_value<const VkVideoSessionKHR>(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + 1, dump_text_VkVideoSessionKHR);  // AET
    dump_text_value<const VkVideoSessionParametersKHR>(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + 1, dump_text_VkVideoSessionParametersKHR);  // AET
    dump_text_value<const uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoReferenceSlotInfoKHR>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "const VkVideoReferenceSlotInfoKHR", "pReferenceSlots", indents + 1, dump_text_VkVideoReferenceSlotInfoKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEndCodingFlagsKHR>(object.flags, settings, "VkVideoEndCodingFlagsKHR", "flags", indents + 1, dump_text_VkVideoEndCodingFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoCodingControlFlagsKHR>(object.flags, settings, "VkVideoCodingControlFlagsKHR", "flags", indents + 1, dump_text_VkVideoCodingControlFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoDecodeCapabilityFlagsKHR>(object.flags, settings, "VkVideoDecodeCapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoDecodeCapabilityFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoDecodeUsageFlagsKHR>(object.videoUsageHints, settings, "VkVideoDecodeUsageFlagsKHR", "videoUsageHints", indents + 1, dump_text_VkVideoDecodeUsageFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoDecodeFlagsKHR>(object.flags, settings, "VkVideoDecodeFlagsKHR", "flags", indents + 1, dump_text_VkVideoDecodeFlagsKHR);  // AET
    dump_text_value<const VkBuffer>(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.srcBufferOffset, settings, "VkDeviceSize", "srcBufferOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.srcBufferRange, settings, "VkDeviceSize", "srcBufferRange", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkVideoPictureResourceInfoKHR>(object.dstPictureResource, settings, "VkVideoPictureResourceInfoKHR", "dstPictureResource", indents + 1, dump_text_VkVideoPictureResourceInfoKHR);  // AET
    dump_text_pointer<const VkVideoReferenceSlotInfoKHR>(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + 1, dump_text_VkVideoReferenceSlotInfoKHR);
    dump_text_value<const uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoReferenceSlotInfoKHR>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "const VkVideoReferenceSlotInfoKHR", "pReferenceSlots", indents + 1, dump_text_VkVideoReferenceSlotInfoKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.transformFeedback, settings, "VkBool32", "transformFeedback", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.geometryStreams, settings, "VkBool32", "geometryStreams", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxTransformFeedbackStreams, settings, "uint32_t", "maxTransformFeedbackStreams", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTransformFeedbackBuffers, settings, "uint32_t", "maxTransformFeedbackBuffers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.maxTransformFeedbackBufferSize, settings, "VkDeviceSize", "maxTransformFeedbackBufferSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.maxTransformFeedbackStreamDataSize, settings, "uint32_t", "maxTransformFeedbackStreamDataSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTransformFeedbackBufferDataSize, settings, "uint32_t", "maxTransformFeedbackBufferDataSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTransformFeedbackBufferDataStride, settings, "uint32_t", "maxTransformFeedbackBufferDataStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackQueries, settings, "VkBool32", "transformFeedbackQueries", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackStreamsLinesTriangles, settings, "VkBool32", "transformFeedbackStreamsLinesTriangles", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackRasterizationStreamSelect, settings, "VkBool32", "transformFeedbackRasterizationStreamSelect", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackDraw, settings, "VkBool32", "transformFeedbackDraw", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineRasterizationStateStreamCreateFlagsEXT>(object.flags, settings, "VkPipelineRasterizationStateStreamCreateFlagsEXT", "flags", indents + 1, dump_text_VkPipelineRasterizationStateStreamCreateFlagsEXT);  // AET
    dump_text_value<const uint32_t>(object.rasterizationStream, settings, "uint32_t", "rasterizationStream", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const size_t>(object.dataSize, settings, "size_t", "dataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "const void*", "pData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCuModuleTexturingModeCreateInfoNVX(const VkCuModuleTexturingModeCreateInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.use64bitTexturing, settings, "VkBool32", "use64bitTexturing", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCuModuleNVX>(object.module, settings, "VkCuModuleNVX", "module", indents + 1, dump_text_VkCuModuleNVX);  // AET
    dump_text_value<const char*>(object.pName, settings, "const char*", "pName", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCuFunctionNVX>(object.function, settings, "VkCuFunctionNVX", "function", indents + 1, dump_text_VkCuFunctionNVX);  // AET
    dump_text_value<const uint32_t>(object.gridDimX, settings, "uint32_t", "gridDimX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gridDimY, settings, "uint32_t", "gridDimY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimX, settings, "uint32_t", "blockDimX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimY, settings, "uint32_t", "blockDimY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.paramCount, settings, "size_t", "paramCount", indents + 1, dump_text_size_t);  // AET
    dump_text_array<const void*>(object.pParams, object.paramCount, settings, "const void* const *", "const void* const ", "pParams", indents + 1, dump_text_void); // BQB
    dump_text_value<const size_t>(object.extraCount, settings, "size_t", "extraCount", indents + 1, dump_text_size_t);  // AET
    dump_text_array<const void*>(object.pExtras, object.extraCount, settings, "const void* const *", "const void* const ", "pExtras", indents + 1, dump_text_void); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkDescriptorType>(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + 1, dump_text_VkDescriptorType);  // AET
    dump_text_value<const VkSampler>(object.sampler, settings, "VkSampler", "sampler", indents + 1, dump_text_VkSampler);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeH264CapabilityFlagsKHR>(object.flags, settings, "VkVideoEncodeH264CapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeH264CapabilityFlagsKHR);  // AET
    dump_text_value<const StdVideoH264LevelIdc>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH264LevelIdc);  // AET
    dump_text_value<const uint32_t>(object.maxSliceCount, settings, "uint32_t", "maxSliceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.expectDyadicTemporalLayerPattern, settings, "VkBool32", "expectDyadicTemporalLayerPattern", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const int32_t>(object.minQp, settings, "int32_t", "minQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.maxQp, settings, "int32_t", "maxQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH264StdFlagsKHR>(object.stdSyntaxFlags, settings, "VkVideoEncodeH264StdFlagsKHR", "stdSyntaxFlags", indents + 1, dump_text_VkVideoEncodeH264StdFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264QpKHR(const VkVideoEncodeH264QpKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const int32_t>(object.qpI, settings, "int32_t", "qpI", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.qpP, settings, "int32_t", "qpP", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.qpB, settings, "int32_t", "qpB", indents + 1, dump_text_int32_t);  // AET
}
void dump_text_VkVideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeH264RateControlFlagsKHR>(object.preferredRateControlFlags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "preferredRateControlFlags", indents + 1, dump_text_VkVideoEncodeH264RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVideoEncodeH264QpKHR>(object.preferredConstantQp, settings, "VkVideoEncodeH264QpKHR", "preferredConstantQp", indents + 1, dump_text_VkVideoEncodeH264QpKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.preferredStdEntropyCodingModeFlag, settings, "VkBool32", "preferredStdEntropyCodingModeFlag", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const StdVideoH264LevelIdc>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH264LevelIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH264SequenceParameterSet>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "const StdVideoH264SequenceParameterSet", "pStdSPSs", indents + 1, dump_text_StdVideoH264SequenceParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH264PictureParameterSet>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "const StdVideoH264PictureParameterSet", "pStdPPSs", indents + 1, dump_text_StdVideoH264PictureParameterSet); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkVideoEncodeH264SessionParametersAddInfoKHR>(object.pParametersAddInfo, settings, "const VkVideoEncodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + 1, dump_text_VkVideoEncodeH264SessionParametersAddInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const int32_t>(object.constantQp, settings, "int32_t", "constantQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_pointer<const StdVideoEncodeH264SliceHeader>(object.pStdSliceHeader, settings, "const StdVideoEncodeH264SliceHeader*", "pStdSliceHeader", indents + 1, dump_text_StdVideoEncodeH264SliceHeader);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.naluSliceEntryCount, settings, "uint32_t", "naluSliceEntryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoEncodeH264NaluSliceInfoKHR>(object.pNaluSliceEntries, object.naluSliceEntryCount, settings, "const VkVideoEncodeH264NaluSliceInfoKHR*", "const VkVideoEncodeH264NaluSliceInfoKHR", "pNaluSliceEntries", indents + 1, dump_text_VkVideoEncodeH264NaluSliceInfoKHR); // BQB
    dump_text_pointer<const StdVideoEncodeH264PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoEncodeH264PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoEncodeH264PictureInfo);
    dump_text_value<const VkBool32>(object.generatePrefixNalu, settings, "VkBool32", "generatePrefixNalu", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoEncodeH264ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoEncodeH264ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoEncodeH264ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoH264ProfileIdc>(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + 1, dump_text_StdVideoH264ProfileIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeH264RateControlFlagsKHR>(object.flags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeH264RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264FrameSizeKHR(const VkVideoEncodeH264FrameSizeKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.frameISize, settings, "uint32_t", "frameISize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.framePSize, settings, "uint32_t", "framePSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.frameBSize, settings, "uint32_t", "frameBSize", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkVideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMinQp, settings, "VkBool32", "useMinQp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH264QpKHR>(object.minQp, settings, "VkVideoEncodeH264QpKHR", "minQp", indents + 1, dump_text_VkVideoEncodeH264QpKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH264QpKHR>(object.maxQp, settings, "VkVideoEncodeH264QpKHR", "maxQp", indents + 1, dump_text_VkVideoEncodeH264QpKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH264FrameSizeKHR>(object.maxFrameSize, settings, "VkVideoEncodeH264FrameSizeKHR", "maxFrameSize", indents + 1, dump_text_VkVideoEncodeH264FrameSizeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeH265CapabilityFlagsKHR>(object.flags, settings, "VkVideoEncodeH265CapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeH265CapabilityFlagsKHR);  // AET
    dump_text_value<const StdVideoH265LevelIdc>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH265LevelIdc);  // AET
    dump_text_value<const uint32_t>(object.maxSliceSegmentCount, settings, "uint32_t", "maxSliceSegmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent2D>(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkVideoEncodeH265CtbSizeFlagsKHR>(object.ctbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "ctbSizes", indents + 1, dump_text_VkVideoEncodeH265CtbSizeFlagsKHR);  // AET
    dump_text_value<const VkVideoEncodeH265TransformBlockSizeFlagsKHR>(object.transformBlockSizes, settings, "VkVideoEncodeH265TransformBlockSizeFlagsKHR", "transformBlockSizes", indents + 1, dump_text_VkVideoEncodeH265TransformBlockSizeFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSubLayerCount, settings, "uint32_t", "maxSubLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.expectDyadicTemporalSubLayerPattern, settings, "VkBool32", "expectDyadicTemporalSubLayerPattern", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const int32_t>(object.minQp, settings, "int32_t", "minQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.maxQp, settings, "int32_t", "maxQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH265StdFlagsKHR>(object.stdSyntaxFlags, settings, "VkVideoEncodeH265StdFlagsKHR", "stdSyntaxFlags", indents + 1, dump_text_VkVideoEncodeH265StdFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const StdVideoH265LevelIdc>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH265LevelIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265QpKHR(const VkVideoEncodeH265QpKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const int32_t>(object.qpI, settings, "int32_t", "qpI", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.qpP, settings, "int32_t", "qpP", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.qpB, settings, "int32_t", "qpB", indents + 1, dump_text_int32_t);  // AET
}
void dump_text_VkVideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeH265RateControlFlagsKHR>(object.preferredRateControlFlags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "preferredRateControlFlags", indents + 1, dump_text_VkVideoEncodeH265RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredSubLayerCount, settings, "uint32_t", "preferredSubLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVideoEncodeH265QpKHR>(object.preferredConstantQp, settings, "VkVideoEncodeH265QpKHR", "preferredConstantQp", indents + 1, dump_text_VkVideoEncodeH265QpKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265VideoParameterSet>(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "const StdVideoH265VideoParameterSet", "pStdVPSs", indents + 1, dump_text_StdVideoH265VideoParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265SequenceParameterSet>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "const StdVideoH265SequenceParameterSet", "pStdSPSs", indents + 1, dump_text_StdVideoH265SequenceParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265PictureParameterSet>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "const StdVideoH265PictureParameterSet", "pStdPPSs", indents + 1, dump_text_StdVideoH265PictureParameterSet); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkVideoEncodeH265SessionParametersAddInfoKHR>(object.pParametersAddInfo, settings, "const VkVideoEncodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + 1, dump_text_VkVideoEncodeH265SessionParametersAddInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.writeStdVPS, settings, "VkBool32", "writeStdVPS", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.stdVPSId, settings, "uint32_t", "stdVPSId", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hasStdVPSOverrides, settings, "VkBool32", "hasStdVPSOverrides", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const int32_t>(object.constantQp, settings, "int32_t", "constantQp", indents + 1, dump_text_int32_t);  // AET
    dump_text_pointer<const StdVideoEncodeH265SliceSegmentHeader>(object.pStdSliceSegmentHeader, settings, "const StdVideoEncodeH265SliceSegmentHeader*", "pStdSliceSegmentHeader", indents + 1, dump_text_StdVideoEncodeH265SliceSegmentHeader);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.naluSliceSegmentEntryCount, settings, "uint32_t", "naluSliceSegmentEntryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoEncodeH265NaluSliceSegmentInfoKHR>(object.pNaluSliceSegmentEntries, object.naluSliceSegmentEntryCount, settings, "const VkVideoEncodeH265NaluSliceSegmentInfoKHR*", "const VkVideoEncodeH265NaluSliceSegmentInfoKHR", "pNaluSliceSegmentEntries", indents + 1, dump_text_VkVideoEncodeH265NaluSliceSegmentInfoKHR); // BQB
    dump_text_pointer<const StdVideoEncodeH265PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoEncodeH265PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoEncodeH265PictureInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoEncodeH265ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoEncodeH265ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoEncodeH265ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoH265ProfileIdc>(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + 1, dump_text_StdVideoH265ProfileIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeH265RateControlFlagsKHR>(object.flags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeH265RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.subLayerCount, settings, "uint32_t", "subLayerCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265FrameSizeKHR(const VkVideoEncodeH265FrameSizeKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.frameISize, settings, "uint32_t", "frameISize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.framePSize, settings, "uint32_t", "framePSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.frameBSize, settings, "uint32_t", "frameBSize", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkVideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMinQp, settings, "VkBool32", "useMinQp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH265QpKHR>(object.minQp, settings, "VkVideoEncodeH265QpKHR", "minQp", indents + 1, dump_text_VkVideoEncodeH265QpKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH265QpKHR>(object.maxQp, settings, "VkVideoEncodeH265QpKHR", "maxQp", indents + 1, dump_text_VkVideoEncodeH265QpKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeH265FrameSizeKHR>(object.maxFrameSize, settings, "VkVideoEncodeH265FrameSizeKHR", "maxFrameSize", indents + 1, dump_text_VkVideoEncodeH265FrameSizeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoH264ProfileIdc>(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + 1, dump_text_StdVideoH264ProfileIdc);  // AET
    dump_text_value<const VkVideoDecodeH264PictureLayoutFlagBitsKHR>(object.pictureLayout, settings, "VkVideoDecodeH264PictureLayoutFlagBitsKHR", "pictureLayout", indents + 1, dump_text_VkVideoDecodeH264PictureLayoutFlagBitsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const StdVideoH264LevelIdc>(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH264LevelIdc);  // AET
    dump_text_value<const VkOffset2D>(object.fieldOffsetGranularity, settings, "VkOffset2D", "fieldOffsetGranularity", indents + 1, dump_text_VkOffset2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH264SequenceParameterSet>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "const StdVideoH264SequenceParameterSet", "pStdSPSs", indents + 1, dump_text_StdVideoH264SequenceParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH264PictureParameterSet>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "const StdVideoH264PictureParameterSet", "pStdPPSs", indents + 1, dump_text_StdVideoH264PictureParameterSet); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkVideoDecodeH264SessionParametersAddInfoKHR>(object.pParametersAddInfo, settings, "const VkVideoDecodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + 1, dump_text_VkVideoDecodeH264SessionParametersAddInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeH264PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoDecodeH264PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoDecodeH264PictureInfo);
    dump_text_value<const uint32_t>(object.sliceCount, settings, "uint32_t", "sliceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pSliceOffsets, object.sliceCount, settings, "const uint32_t*", "const uint32_t", "pSliceOffsets", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeH264ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoDecodeH264ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoDecodeH264ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.supportsTextureGatherLODBiasAMD, settings, "VkBool32", "supportsTextureGatherLODBiasAMD", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkShaderResourceUsageAMD(const VkShaderResourceUsageAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.numUsedVgprs, settings, "uint32_t", "numUsedVgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.numUsedSgprs, settings, "uint32_t", "numUsedSgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.ldsSizePerLocalWorkGroup, settings, "uint32_t", "ldsSizePerLocalWorkGroup", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.ldsUsageSizeInBytes, settings, "size_t", "ldsUsageSizeInBytes", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.scratchMemUsageInBytes, settings, "size_t", "scratchMemUsageInBytes", indents + 1, dump_text_size_t);  // AET
}
void dump_text_VkShaderStatisticsInfoAMD(const VkShaderStatisticsInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkShaderStageFlags>(object.shaderStageMask, settings, "VkShaderStageFlags", "shaderStageMask", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkShaderResourceUsageAMD>(object.resourceUsage, settings, "VkShaderResourceUsageAMD", "resourceUsage", indents + 1, dump_text_VkShaderResourceUsageAMD);  // AET
    dump_text_value<const uint32_t>(object.numPhysicalVgprs, settings, "uint32_t", "numPhysicalVgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.numPhysicalSgprs, settings, "uint32_t", "numPhysicalSgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.numAvailableVgprs, settings, "uint32_t", "numAvailableVgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.numAvailableSgprs, settings, "uint32_t", "numAvailableSgprs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.computeWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "computeWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
}
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkStreamDescriptorSurfaceCreateFlagsGGP>(object.flags, settings, "VkStreamDescriptorSurfaceCreateFlagsGGP", "flags", indents + 1, dump_text_VkStreamDescriptorSurfaceCreateFlagsGGP);  // AET
    dump_text_value<const GgpStreamDescriptor>(object.streamDescriptor, settings, "GgpStreamDescriptor", "streamDescriptor", indents + 1, dump_text_GgpStreamDescriptor);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_GGP
void dump_text_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cornerSampledImage, settings, "VkBool32", "cornerSampledImage", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalImageFormatPropertiesNV(const VkExternalImageFormatPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkImageFormatProperties>(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + 1, dump_text_VkImageFormatProperties);  // AET
    dump_text_value<const VkExternalMemoryFeatureFlagsNV>(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlagsNV", "externalMemoryFeatures", indents + 1, dump_text_VkExternalMemoryFeatureFlagsNV);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "exportFromImportedHandleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagsNV);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "compatibleHandleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagsNV);  // AET
}
void dump_text_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagsNV);  // AET
    dump_text_value<const HANDLE>(object.handle, settings, "HANDLE", "handle", indents + 1, dump_text_HANDLE);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + 1, dump_text_SECURITY_ATTRIBUTES);  // AET
    dump_text_value<const DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + 1, dump_text_DWORD);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.acquireCount, settings, "uint32_t", "acquireCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceMemory>(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "const VkDeviceMemory", "pAcquireSyncs", indents + 1, dump_text_VkDeviceMemory); // BQB
    dump_text_array<const uint64_t>(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "const uint64_t", "pAcquireKeys", indents + 1, dump_text_uint64_t); // BQB
    dump_text_array<const uint32_t>(object.pAcquireTimeoutMilliseconds, object.acquireCount, settings, "const uint32_t*", "const uint32_t", "pAcquireTimeoutMilliseconds", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.releaseCount, settings, "uint32_t", "releaseCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceMemory>(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "const VkDeviceMemory", "pReleaseSyncs", indents + 1, dump_text_VkDeviceMemory); // BQB
    dump_text_array<const uint64_t>(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "const uint64_t", "pReleaseKeys", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkValidationFlagsEXT(const VkValidationFlagsEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.disabledValidationCheckCount, settings, "uint32_t", "disabledValidationCheckCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkValidationCheckEXT>(object.pDisabledValidationChecks, object.disabledValidationCheckCount, settings, "const VkValidationCheckEXT*", "const VkValidationCheckEXT", "pDisabledValidationChecks", indents + 1, dump_text_VkValidationCheckEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_VI_NN)
void dump_text_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkViSurfaceCreateFlagsNN>(object.flags, settings, "VkViSurfaceCreateFlagsNN", "flags", indents + 1, dump_text_VkViSurfaceCreateFlagsNN);  // AET
    dump_text_value<const void*>(object.window, settings, "void*", "window", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_VI_NN
void dump_text_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.decodeMode, settings, "VkFormat", "decodeMode", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.decodeModeSharedExponent, settings, "VkBool32", "decodeModeSharedExponent", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    dump_text_value<const HANDLE>(object.handle, settings, "HANDLE", "handle", indents + 1, dump_text_HANDLE);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + 1, dump_text_SECURITY_ATTRIBUTES);  // AET
    dump_text_value<const DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + 1, dump_text_DWORD);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    dump_text_value<const int>(object.fd, settings, "int", "fd", indents + 1, dump_text_int);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.acquireCount, settings, "uint32_t", "acquireCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceMemory>(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "const VkDeviceMemory", "pAcquireSyncs", indents + 1, dump_text_VkDeviceMemory); // BQB
    dump_text_array<const uint64_t>(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "const uint64_t", "pAcquireKeys", indents + 1, dump_text_uint64_t); // BQB
    dump_text_array<const uint32_t>(object.pAcquireTimeouts, object.acquireCount, settings, "const uint32_t*", "const uint32_t", "pAcquireTimeouts", indents + 1, dump_text_uint32_t); // BQB
    dump_text_value<const uint32_t>(object.releaseCount, settings, "uint32_t", "releaseCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceMemory>(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "const VkDeviceMemory", "pReleaseSyncs", indents + 1, dump_text_VkDeviceMemory); // BQB
    dump_text_array<const uint64_t>(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "const uint64_t", "pReleaseKeys", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkSemaphoreImportFlags>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + 1, dump_text_VkSemaphoreImportFlags);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    dump_text_value<const HANDLE>(object.handle, settings, "HANDLE", "handle", indents + 1, dump_text_HANDLE);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + 1, dump_text_SECURITY_ATTRIBUTES);  // AET
    dump_text_value<const DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + 1, dump_text_DWORD);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.waitSemaphoreValuesCount, settings, "uint32_t", "waitSemaphoreValuesCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pWaitSemaphoreValues, object.waitSemaphoreValuesCount, settings, "const uint64_t*", "const uint64_t", "pWaitSemaphoreValues", indents + 1, dump_text_uint64_t); // BQB
    dump_text_value<const uint32_t>(object.signalSemaphoreValuesCount, settings, "uint32_t", "signalSemaphoreValuesCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pSignalSemaphoreValues, object.signalSemaphoreValuesCount, settings, "const uint64_t*", "const uint64_t", "pSignalSemaphoreValues", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkSemaphoreImportFlags>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + 1, dump_text_VkSemaphoreImportFlags);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    dump_text_value<const int>(object.fd, settings, "int", "fd", indents + 1, dump_text_int);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkConditionalRenderingFlagsEXT>(object.flags, settings, "VkConditionalRenderingFlagsEXT", "flags", indents + 1, dump_text_VkConditionalRenderingFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.conditionalRendering, settings, "VkBool32", "conditionalRendering", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.inheritedConditionalRendering, settings, "VkBool32", "inheritedConditionalRendering", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.conditionalRenderingEnable, settings, "VkBool32", "conditionalRenderingEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRectLayerKHR(const VkRectLayerKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkOffset2D>(object.offset, settings, "VkOffset2D", "offset", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.extent, settings, "VkExtent2D", "extent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.layer, settings, "uint32_t", "layer", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPresentRegionKHR(const VkPresentRegionKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.rectangleCount, settings, "uint32_t", "rectangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRectLayerKHR>(object.pRectangles, object.rectangleCount, settings, "const VkRectLayerKHR*", "const VkRectLayerKHR", "pRectangles", indents + 1, dump_text_VkRectLayerKHR); // BQB
}
void dump_text_VkPresentRegionsKHR(const VkPresentRegionsKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentRegionKHR>(object.pRegions, object.swapchainCount, settings, "const VkPresentRegionKHR*", "const VkPresentRegionKHR", "pRegions", indents + 1, dump_text_VkPresentRegionKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkViewportWScalingNV(const VkViewportWScalingNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.xcoeff, settings, "float", "xcoeff", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.ycoeff, settings, "float", "ycoeff", indents + 1, dump_text_float);  // AET
}
void dump_text_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkViewportWScalingNV>(object.pViewportWScalings, object.viewportCount, settings, "const VkViewportWScalingNV*", "const VkViewportWScalingNV", "pViewportWScalings", indents + 1, dump_text_VkViewportWScalingNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.minImageCount, settings, "uint32_t", "minImageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent2D>(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSurfaceTransformFlagsKHR>(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + 1, dump_text_VkSurfaceTransformFlagsKHR);  // AET
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    dump_text_value<const VkCompositeAlphaFlagsKHR>(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + 1, dump_text_VkCompositeAlphaFlagsKHR);  // AET
    dump_text_value<const VkImageUsageFlags>(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkSurfaceCounterFlagsEXT>(object.supportedSurfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "supportedSurfaceCounters", indents + 1, dump_text_VkSurfaceCounterFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplayPowerStateEXT>(object.powerState, settings, "VkDisplayPowerStateEXT", "powerState", indents + 1, dump_text_VkDisplayPowerStateEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceEventTypeEXT>(object.deviceEvent, settings, "VkDeviceEventTypeEXT", "deviceEvent", indents + 1, dump_text_VkDeviceEventTypeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplayEventTypeEXT>(object.displayEvent, settings, "VkDisplayEventTypeEXT", "displayEvent", indents + 1, dump_text_VkDisplayEventTypeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSurfaceCounterFlagsEXT>(object.surfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "surfaceCounters", indents + 1, dump_text_VkSurfaceCounterFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRefreshCycleDurationGOOGLE(const VkRefreshCycleDurationGOOGLE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint64_t>(object.refreshDuration, settings, "uint64_t", "refreshDuration", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkPastPresentationTimingGOOGLE(const VkPastPresentationTimingGOOGLE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.presentID, settings, "uint32_t", "presentID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint64_t>(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.actualPresentTime, settings, "uint64_t", "actualPresentTime", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.earliestPresentTime, settings, "uint64_t", "earliestPresentTime", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.presentMargin, settings, "uint64_t", "presentMargin", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkPresentTimeGOOGLE(const VkPresentTimeGOOGLE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.presentID, settings, "uint32_t", "presentID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint64_t>(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentTimeGOOGLE>(object.pTimes, object.swapchainCount, settings, "const VkPresentTimeGOOGLE*", "const VkPresentTimeGOOGLE", "pTimes", indents + 1, dump_text_VkPresentTimeGOOGLE); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.perViewPositionAllComponents, settings, "VkBool32", "perViewPositionAllComponents", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.perViewAttributes, settings, "VkBool32", "perViewAttributes", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.perViewAttributesPositionXOnly, settings, "VkBool32", "perViewAttributesPositionXOnly", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkViewportSwizzleNV(const VkViewportSwizzleNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkViewportCoordinateSwizzleNV>(object.x, settings, "VkViewportCoordinateSwizzleNV", "x", indents + 1, dump_text_VkViewportCoordinateSwizzleNV);  // AET
    dump_text_value<const VkViewportCoordinateSwizzleNV>(object.y, settings, "VkViewportCoordinateSwizzleNV", "y", indents + 1, dump_text_VkViewportCoordinateSwizzleNV);  // AET
    dump_text_value<const VkViewportCoordinateSwizzleNV>(object.z, settings, "VkViewportCoordinateSwizzleNV", "z", indents + 1, dump_text_VkViewportCoordinateSwizzleNV);  // AET
    dump_text_value<const VkViewportCoordinateSwizzleNV>(object.w, settings, "VkViewportCoordinateSwizzleNV", "w", indents + 1, dump_text_VkViewportCoordinateSwizzleNV);  // AET
}
void dump_text_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineViewportSwizzleStateCreateFlagsNV>(object.flags, settings, "VkPipelineViewportSwizzleStateCreateFlagsNV", "flags", indents + 1, dump_text_VkPipelineViewportSwizzleStateCreateFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkViewportSwizzleNV>(object.pViewportSwizzles, object.viewportCount, settings, "const VkViewportSwizzleNV*", "const VkViewportSwizzleNV", "pViewportSwizzles", indents + 1, dump_text_VkViewportSwizzleNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxDiscardRectangles, settings, "uint32_t", "maxDiscardRectangles", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineDiscardRectangleStateCreateFlagsEXT>(object.flags, settings, "VkPipelineDiscardRectangleStateCreateFlagsEXT", "flags", indents + 1, dump_text_VkPipelineDiscardRectangleStateCreateFlagsEXT);  // AET
    dump_text_value<const VkDiscardRectangleModeEXT>(object.discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", indents + 1, dump_text_VkDiscardRectangleModeEXT);  // AET
    dump_text_value<const uint32_t>(object.discardRectangleCount, settings, "uint32_t", "discardRectangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pDiscardRectangles, object.discardRectangleCount, settings, "const VkRect2D*", "const VkRect2D", "pDiscardRectangles", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const float>(object.primitiveOverestimationSize, settings, "float", "primitiveOverestimationSize", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxExtraPrimitiveOverestimationSize, settings, "float", "maxExtraPrimitiveOverestimationSize", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.extraPrimitiveOverestimationSizeGranularity, settings, "float", "extraPrimitiveOverestimationSizeGranularity", indents + 1, dump_text_float);  // AET
    dump_text_value<const VkBool32>(object.primitiveUnderestimation, settings, "VkBool32", "primitiveUnderestimation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.conservativePointAndLineRasterization, settings, "VkBool32", "conservativePointAndLineRasterization", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.degenerateTrianglesRasterized, settings, "VkBool32", "degenerateTrianglesRasterized", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.degenerateLinesRasterized, settings, "VkBool32", "degenerateLinesRasterized", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fullyCoveredFragmentShaderInputVariable, settings, "VkBool32", "fullyCoveredFragmentShaderInputVariable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.conservativeRasterizationPostDepthCoverage, settings, "VkBool32", "conservativeRasterizationPostDepthCoverage", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineRasterizationConservativeStateCreateFlagsEXT>(object.flags, settings, "VkPipelineRasterizationConservativeStateCreateFlagsEXT", "flags", indents + 1, dump_text_VkPipelineRasterizationConservativeStateCreateFlagsEXT);  // AET
    dump_text_value<const VkConservativeRasterizationModeEXT>(object.conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", indents + 1, dump_text_VkConservativeRasterizationModeEXT);  // AET
    dump_text_value<const float>(object.extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineRasterizationDepthClipStateCreateFlagsEXT>(object.flags, settings, "VkPipelineRasterizationDepthClipStateCreateFlagsEXT", "flags", indents + 1, dump_text_VkPipelineRasterizationDepthClipStateCreateFlagsEXT);  // AET
    dump_text_value<const VkBool32>(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkXYColorEXT(const VkXYColorEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.x, settings, "float", "x", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.y, settings, "float", "y", indents + 1, dump_text_float);  // AET
}
void dump_text_VkHdrMetadataEXT(const VkHdrMetadataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkXYColorEXT>(object.displayPrimaryRed, settings, "VkXYColorEXT", "displayPrimaryRed", indents + 1, dump_text_VkXYColorEXT);  // AET
    dump_text_value<const VkXYColorEXT>(object.displayPrimaryGreen, settings, "VkXYColorEXT", "displayPrimaryGreen", indents + 1, dump_text_VkXYColorEXT);  // AET
    dump_text_value<const VkXYColorEXT>(object.displayPrimaryBlue, settings, "VkXYColorEXT", "displayPrimaryBlue", indents + 1, dump_text_VkXYColorEXT);  // AET
    dump_text_value<const VkXYColorEXT>(object.whitePoint, settings, "VkXYColorEXT", "whitePoint", indents + 1, dump_text_VkXYColorEXT);  // AET
    dump_text_value<const float>(object.maxLuminance, settings, "float", "maxLuminance", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.minLuminance, settings, "float", "minLuminance", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxContentLightLevel, settings, "float", "maxContentLightLevel", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxFrameAverageLightLevel, settings, "float", "maxFrameAverageLightLevel", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.relaxedLineRasterization, settings, "VkBool32", "relaxedLineRasterization", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageUsageFlags>(object.sharedPresentSupportedUsageFlags, settings, "VkImageUsageFlags", "sharedPresentSupportedUsageFlags", indents + 1, dump_text_VkImageUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFence>(object.fence, settings, "VkFence", "fence", indents + 1, dump_text_VkFence);  // AET
    dump_text_value<const VkFenceImportFlags>(object.flags, settings, "VkFenceImportFlags", "flags", indents + 1, dump_text_VkFenceImportFlags);  // AET
    dump_text_value<const VkExternalFenceHandleTypeFlagBits>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalFenceHandleTypeFlagBits);  // AET
    dump_text_value<const HANDLE>(object.handle, settings, "HANDLE", "handle", indents + 1, dump_text_HANDLE);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const SECURITY_ATTRIBUTES*>(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + 1, dump_text_SECURITY_ATTRIBUTES);  // AET
    dump_text_value<const DWORD>(object.dwAccess, settings, "DWORD", "dwAccess", indents + 1, dump_text_DWORD);  // AET
    dump_text_value<const LPCWSTR>(object.name, settings, "LPCWSTR", "name", indents + 1, dump_text_LPCWSTR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFence>(object.fence, settings, "VkFence", "fence", indents + 1, dump_text_VkFence);  // AET
    dump_text_value<const VkExternalFenceHandleTypeFlagBits>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalFenceHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFence>(object.fence, settings, "VkFence", "fence", indents + 1, dump_text_VkFence);  // AET
    dump_text_value<const VkFenceImportFlags>(object.flags, settings, "VkFenceImportFlags", "flags", indents + 1, dump_text_VkFenceImportFlags);  // AET
    dump_text_value<const VkExternalFenceHandleTypeFlagBits>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalFenceHandleTypeFlagBits);  // AET
    dump_text_value<const int>(object.fd, settings, "int", "fd", indents + 1, dump_text_int);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFence>(object.fence, settings, "VkFence", "fence", indents + 1, dump_text_VkFence);  // AET
    dump_text_value<const VkExternalFenceHandleTypeFlagBits>(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalFenceHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.performanceCounterQueryPools, settings, "VkBool32", "performanceCounterQueryPools", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.performanceCounterMultipleQueryPools, settings, "VkBool32", "performanceCounterMultipleQueryPools", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.allowCommandBufferQueryCopies, settings, "VkBool32", "allowCommandBufferQueryCopies", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceCounterKHR(const VkPerformanceCounterKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPerformanceCounterUnitKHR>(object.unit, settings, "VkPerformanceCounterUnitKHR", "unit", indents + 1, dump_text_VkPerformanceCounterUnitKHR);  // AET
    dump_text_value<const VkPerformanceCounterScopeKHR>(object.scope, settings, "VkPerformanceCounterScopeKHR", "scope", indents + 1, dump_text_VkPerformanceCounterScopeKHR);  // AET
    dump_text_value<const VkPerformanceCounterStorageKHR>(object.storage, settings, "VkPerformanceCounterStorageKHR", "storage", indents + 1, dump_text_VkPerformanceCounterStorageKHR);  // AET
    dump_text_array<const uint8_t>(object.uuid, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "uuid", indents + 1, dump_text_uint8_t); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPerformanceCounterDescriptionFlagsKHR>(object.flags, settings, "VkPerformanceCounterDescriptionFlagsKHR", "flags", indents + 1, dump_text_VkPerformanceCounterDescriptionFlagsKHR);  // AET
    dump_text_value<const char*>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.category, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "category", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.counterIndexCount, settings, "uint32_t", "counterIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pCounterIndices, object.counterIndexCount, settings, "const uint32_t*", "const uint32_t", "pCounterIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAcquireProfilingLockFlagsKHR>(object.flags, settings, "VkAcquireProfilingLockFlagsKHR", "flags", indents + 1, dump_text_VkAcquireProfilingLockFlagsKHR);  // AET
    dump_text_value<const uint64_t>(object.timeout, settings, "uint64_t", "timeout", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.counterPassIndex, settings, "uint32_t", "counterPassIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSurfaceKHR>(object.surface, settings, "VkSurfaceKHR", "surface", indents + 1, dump_text_VkSurfaceKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSurfaceCapabilitiesKHR>(object.surfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR", "surfaceCapabilities", indents + 1, dump_text_VkSurfaceCapabilitiesKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSurfaceFormatKHR>(object.surfaceFormat, settings, "VkSurfaceFormatKHR", "surfaceFormat", indents + 1, dump_text_VkSurfaceFormatKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayProperties2KHR(const VkDisplayProperties2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDisplayPropertiesKHR>(object.displayProperties, settings, "VkDisplayPropertiesKHR", "displayProperties", indents + 1, dump_text_VkDisplayPropertiesKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDisplayPlanePropertiesKHR>(object.displayPlaneProperties, settings, "VkDisplayPlanePropertiesKHR", "displayPlaneProperties", indents + 1, dump_text_VkDisplayPlanePropertiesKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDisplayModePropertiesKHR>(object.displayModeProperties, settings, "VkDisplayModePropertiesKHR", "displayModeProperties", indents + 1, dump_text_VkDisplayModePropertiesKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplayModeKHR>(object.mode, settings, "VkDisplayModeKHR", "mode", indents + 1, dump_text_VkDisplayModeKHR);  // AET
    dump_text_value<const uint32_t>(object.planeIndex, settings, "uint32_t", "planeIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDisplayPlaneCapabilitiesKHR>(object.capabilities, settings, "VkDisplayPlaneCapabilitiesKHR", "capabilities", indents + 1, dump_text_VkDisplayPlaneCapabilitiesKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_IOS_MVK)
void dump_text_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIOSSurfaceCreateFlagsMVK>(object.flags, settings, "VkIOSSurfaceCreateFlagsMVK", "flags", indents + 1, dump_text_VkIOSSurfaceCreateFlagsMVK);  // AET
    dump_text_value<const void*>(object.pView, settings, "const void*", "pView", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
void dump_text_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMacOSSurfaceCreateFlagsMVK>(object.flags, settings, "VkMacOSSurfaceCreateFlagsMVK", "flags", indents + 1, dump_text_VkMacOSSurfaceCreateFlagsMVK);  // AET
    dump_text_value<const void*>(object.pView, settings, "const void*", "pView", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_MACOS_MVK
void dump_text_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const char*>(object.pLabelName, settings, "const char*", "pLabelName", indents + 1, dump_text_cstring);  // AET
    dump_text_array<const float>(object.color, 4, settings, "float[4]", "float", "color", indents + 1, dump_text_float); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkObjectType>(object.objectType, settings, "VkObjectType", "objectType", indents + 1, dump_text_VkObjectType);  // AET
    dump_text_value<const uint64_t>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const char*>(object.pObjectName, settings, "const char*", "pObjectName", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDebugUtilsMessengerCallbackDataFlagsEXT>(object.flags, settings, "VkDebugUtilsMessengerCallbackDataFlagsEXT", "flags", indents + 1, dump_text_VkDebugUtilsMessengerCallbackDataFlagsEXT);  // AET
    dump_text_value<const char*>(object.pMessageIdName, settings, "const char*", "pMessageIdName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const int32_t>(object.messageIdNumber, settings, "int32_t", "messageIdNumber", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const char*>(object.pMessage, settings, "const char*", "pMessage", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.queueLabelCount, settings, "uint32_t", "queueLabelCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDebugUtilsLabelEXT>(object.pQueueLabels, object.queueLabelCount, settings, "const VkDebugUtilsLabelEXT*", "const VkDebugUtilsLabelEXT", "pQueueLabels", indents + 1, dump_text_VkDebugUtilsLabelEXT); // BQB
    dump_text_value<const uint32_t>(object.cmdBufLabelCount, settings, "uint32_t", "cmdBufLabelCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDebugUtilsLabelEXT>(object.pCmdBufLabels, object.cmdBufLabelCount, settings, "const VkDebugUtilsLabelEXT*", "const VkDebugUtilsLabelEXT", "pCmdBufLabels", indents + 1, dump_text_VkDebugUtilsLabelEXT); // BQB
    dump_text_value<const uint32_t>(object.objectCount, settings, "uint32_t", "objectCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDebugUtilsObjectNameInfoEXT>(object.pObjects, object.objectCount, settings, "const VkDebugUtilsObjectNameInfoEXT*", "const VkDebugUtilsObjectNameInfoEXT", "pObjects", indents + 1, dump_text_VkDebugUtilsObjectNameInfoEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDebugUtilsMessengerCreateFlagsEXT>(object.flags, settings, "VkDebugUtilsMessengerCreateFlagsEXT", "flags", indents + 1, dump_text_VkDebugUtilsMessengerCreateFlagsEXT);  // AET
    dump_text_value<const VkDebugUtilsMessageSeverityFlagsEXT>(object.messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagsEXT", "messageSeverity", indents + 1, dump_text_VkDebugUtilsMessageSeverityFlagsEXT);  // AET
    dump_text_value<const VkDebugUtilsMessageTypeFlagsEXT>(object.messageType, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageType", indents + 1, dump_text_VkDebugUtilsMessageTypeFlagsEXT);  // AET
    dump_text_value<const PFN_vkDebugUtilsMessengerCallbackEXT>(object.pfnUserCallback, settings, "PFN_vkDebugUtilsMessengerCallbackEXT", "pfnUserCallback", indents + 1, dump_text_PFN_vkDebugUtilsMessengerCallbackEXT);  // AET
    dump_text_value<const void*>(object.pUserData, settings, "void*", "pUserData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkObjectType>(object.objectType, settings, "VkObjectType", "objectType", indents + 1, dump_text_VkObjectType);  // AET
    dump_text_value<const uint64_t>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const size_t>(object.tagSize, settings, "size_t", "tagSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pTag, settings, "const void*", "pTag", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.androidHardwareBufferUsage, settings, "uint64_t", "androidHardwareBufferUsage", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkComponentMapping>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkSamplerYcbcrModelConversion>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + 1, dump_text_VkSamplerYcbcrModelConversion);  // AET
    dump_text_value<const VkSamplerYcbcrRange>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + 1, dump_text_VkSamplerYcbcrRange);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const AHardwareBuffer*>(object.buffer, settings, "struct AHardwareBuffer*", "buffer", indents + 1, dump_text_AHardwareBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkExternalFormatANDROID(const VkExternalFormatANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkFormatFeatureFlags2>(object.formatFeatures, settings, "VkFormatFeatureFlags2", "formatFeatures", indents + 1, dump_text_VkFormatFeatureFlags2);  // AET
    dump_text_value<const VkComponentMapping>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkSamplerYcbcrModelConversion>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + 1, dump_text_VkSamplerYcbcrModelConversion);  // AET
    dump_text_value<const VkSamplerYcbcrRange>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + 1, dump_text_VkSamplerYcbcrRange);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderEnqueue, settings, "VkBool32", "shaderEnqueue", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderMeshEnqueue, settings, "VkBool32", "shaderMeshEnqueue", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxExecutionGraphDepth, settings, "uint32_t", "maxExecutionGraphDepth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxExecutionGraphShaderOutputNodes, settings, "uint32_t", "maxExecutionGraphShaderOutputNodes", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxExecutionGraphShaderPayloadSize, settings, "uint32_t", "maxExecutionGraphShaderPayloadSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxExecutionGraphShaderPayloadCount, settings, "uint32_t", "maxExecutionGraphShaderPayloadCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.executionGraphDispatchAddressAlignment, settings, "uint32_t", "executionGraphDispatchAddressAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxExecutionGraphWorkgroupCount, 3, settings, "uint32_t[3]", "uint32_t", "maxExecutionGraphWorkgroupCount", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxExecutionGraphWorkgroups, settings, "uint32_t", "maxExecutionGraphWorkgroups", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.minSize, settings, "VkDeviceSize", "minSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.maxSize, settings, "VkDeviceSize", "maxSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.sizeGranularity, settings, "VkDeviceSize", "sizeGranularity", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.libraryCount, settings, "uint32_t", "libraryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipeline>(object.pLibraries, object.libraryCount, settings, "const VkPipeline*", "const VkPipeline", "pLibraries", indents + 1, dump_text_VkPipeline); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + 1, dump_text_VkPipelineCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineShaderStageCreateInfo>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "const VkPipelineShaderStageCreateInfo", "pStages", indents + 1, dump_text_VkPipelineShaderStageCreateInfo); // BQB
    dump_text_pointer<const VkPipelineLibraryCreateInfoKHR>(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + 1, dump_text_VkPipelineLibraryCreateInfoKHR);
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkPipeline>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkDispatchGraphInfoAMDX(const VkDispatchGraphInfoAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.nodeIndex, settings, "uint32_t", "nodeIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.payloadCount, settings, "uint32_t", "payloadCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstAMDX>(object.payloads, settings, "VkDeviceOrHostAddressConstAMDX", "payloads", indents + 1, dump_text_VkDeviceOrHostAddressConstAMDX);  // AET
    dump_text_value<const uint64_t>(object.payloadStride, settings, "uint64_t", "payloadStride", indents + 1, dump_text_uint64_t);  // AET
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkDispatchGraphCountInfoAMDX(const VkDispatchGraphCountInfoAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.count, settings, "uint32_t", "count", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstAMDX>(object.infos, settings, "VkDeviceOrHostAddressConstAMDX", "infos", indents + 1, dump_text_VkDeviceOrHostAddressConstAMDX);  // AET
    dump_text_value<const uint64_t>(object.stride, settings, "uint64_t", "stride", indents + 1, dump_text_uint64_t);  // AET
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const char*>(object.pName, settings, "const char*", "pName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSampleCountFlagBits>(object.pColorAttachmentSamples, object.colorAttachmentCount, settings, "const VkSampleCountFlagBits*", "const VkSampleCountFlagBits", "pColorAttachmentSamples", indents + 1, dump_text_VkSampleCountFlagBits); // BQB
    dump_text_value<const VkSampleCountFlagBits>(object.depthStencilAttachmentSamples, settings, "VkSampleCountFlagBits", "depthStencilAttachmentSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderBfloat16FeaturesKHR(const VkPhysicalDeviceShaderBfloat16FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderBFloat16Type, settings, "VkBool32", "shaderBFloat16Type", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBFloat16DotProduct, settings, "VkBool32", "shaderBFloat16DotProduct", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBFloat16CooperativeMatrix, settings, "VkBool32", "shaderBFloat16CooperativeMatrix", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSampleLocationEXT(const VkSampleLocationEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.x, settings, "float", "x", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.y, settings, "float", "y", indents + 1, dump_text_float);  // AET
}
void dump_text_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSampleCountFlagBits>(object.sampleLocationsPerPixel, settings, "VkSampleCountFlagBits", "sampleLocationsPerPixel", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkExtent2D>(object.sampleLocationGridSize, settings, "VkExtent2D", "sampleLocationGridSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.sampleLocationsCount, settings, "uint32_t", "sampleLocationsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSampleLocationEXT>(object.pSampleLocations, object.sampleLocationsCount, settings, "const VkSampleLocationEXT*", "const VkSampleLocationEXT", "pSampleLocations", indents + 1, dump_text_VkSampleLocationEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.attachmentIndex, settings, "uint32_t", "attachmentIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleLocationsInfoEXT>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + 1, dump_text_VkSampleLocationsInfoEXT);  // AET
}
void dump_text_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.subpassIndex, settings, "uint32_t", "subpassIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleLocationsInfoEXT>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + 1, dump_text_VkSampleLocationsInfoEXT);  // AET
}
void dump_text_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.attachmentInitialSampleLocationsCount, settings, "uint32_t", "attachmentInitialSampleLocationsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAttachmentSampleLocationsEXT>(object.pAttachmentInitialSampleLocations, object.attachmentInitialSampleLocationsCount, settings, "const VkAttachmentSampleLocationsEXT*", "const VkAttachmentSampleLocationsEXT", "pAttachmentInitialSampleLocations", indents + 1, dump_text_VkAttachmentSampleLocationsEXT); // BQB
    dump_text_value<const uint32_t>(object.postSubpassSampleLocationsCount, settings, "uint32_t", "postSubpassSampleLocationsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubpassSampleLocationsEXT>(object.pPostSubpassSampleLocations, object.postSubpassSampleLocationsCount, settings, "const VkSubpassSampleLocationsEXT*", "const VkSubpassSampleLocationsEXT", "pPostSubpassSampleLocations", indents + 1, dump_text_VkSubpassSampleLocationsEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkSampleLocationsInfoEXT>(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + 1, dump_text_VkSampleLocationsInfoEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSampleCountFlags>(object.sampleLocationSampleCounts, settings, "VkSampleCountFlags", "sampleLocationSampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkExtent2D>(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_array<const float>(object.sampleLocationCoordinateRange, 2, settings, "float[2]", "float", "sampleLocationCoordinateRange", indents + 1, dump_text_float); // AQA
    dump_text_value<const uint32_t>(object.sampleLocationSubPixelBits, settings, "uint32_t", "sampleLocationSubPixelBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.variableSampleLocations, settings, "VkBool32", "variableSampleLocations", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.advancedBlendCoherentOperations, settings, "VkBool32", "advancedBlendCoherentOperations", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.advancedBlendMaxColorAttachments, settings, "uint32_t", "advancedBlendMaxColorAttachments", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.advancedBlendIndependentBlend, settings, "VkBool32", "advancedBlendIndependentBlend", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.advancedBlendNonPremultipliedSrcColor, settings, "VkBool32", "advancedBlendNonPremultipliedSrcColor", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.advancedBlendNonPremultipliedDstColor, settings, "VkBool32", "advancedBlendNonPremultipliedDstColor", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.advancedBlendCorrelatedOverlap, settings, "VkBool32", "advancedBlendCorrelatedOverlap", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.advancedBlendAllOperations, settings, "VkBool32", "advancedBlendAllOperations", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBlendOverlapEXT>(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + 1, dump_text_VkBlendOverlapEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCoverageToColorStateCreateFlagsNV>(object.flags, settings, "VkPipelineCoverageToColorStateCreateFlagsNV", "flags", indents + 1, dump_text_VkPipelineCoverageToColorStateCreateFlagsNV);  // AET
    dump_text_value<const VkBool32>(object.coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureBuildRangeInfoKHR(const VkAccelerationStructureBuildRangeInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.primitiveCount, settings, "uint32_t", "primitiveCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.primitiveOffset, settings, "uint32_t", "primitiveOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.transformOffset, settings, "uint32_t", "transformOffset", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkAabbPositionsKHR(const VkAabbPositionsKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.minX, settings, "float", "minX", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.minY, settings, "float", "minY", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.minZ, settings, "float", "minZ", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxX, settings, "float", "maxX", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxY, settings, "float", "maxY", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxZ, settings, "float", "maxZ", indents + 1, dump_text_float);  // AET
}
void dump_text_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.maxVertex, settings, "uint32_t", "maxVertex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.transformData, settings, "VkDeviceOrHostAddressConstKHR", "transformData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTransformMatrixKHR(const VkTransformMatrixKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
}
void dump_text_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.stride, settings, "VkDeviceSize", "stride", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.arrayOfPointers, settings, "VkBool32", "arrayOfPointers", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkGeometryTypeKHR>(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + 1, dump_text_VkGeometryTypeKHR);  // AET
    dump_text_value<const VkAccelerationStructureGeometryDataKHR>(object.geometry, settings, "VkAccelerationStructureGeometryDataKHR", "geometry", indents + 1, dump_text_VkAccelerationStructureGeometryDataKHR);  // AET
    dump_text_value<const VkGeometryFlagsKHR>(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + 1, dump_text_VkGeometryFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureTypeKHR>(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + 1, dump_text_VkAccelerationStructureTypeKHR);  // AET
    dump_text_value<const VkBuildAccelerationStructureFlagsKHR>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + 1, dump_text_VkBuildAccelerationStructureFlagsKHR);  // AET
    dump_text_value<const VkBuildAccelerationStructureModeKHR>(object.mode, settings, "VkBuildAccelerationStructureModeKHR", "mode", indents + 1, dump_text_VkBuildAccelerationStructureModeKHR);  // AET
    dump_text_value<const VkAccelerationStructureKHR>(object.srcAccelerationStructure, settings, "VkAccelerationStructureKHR", "srcAccelerationStructure", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkAccelerationStructureKHR>(object.dstAccelerationStructure, settings, "VkAccelerationStructureKHR", "dstAccelerationStructure", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const uint32_t>(object.geometryCount, settings, "uint32_t", "geometryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAccelerationStructureGeometryKHR>(object.pGeometries, object.geometryCount, settings, "const VkAccelerationStructureGeometryKHR*", "const VkAccelerationStructureGeometryKHR", "pGeometries", indents + 1, dump_text_VkAccelerationStructureGeometryKHR); // BQB
    dump_text_value<const VkDeviceOrHostAddressKHR>(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + 1, dump_text_VkDeviceOrHostAddressKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureInstanceKHR(const VkAccelerationStructureInstanceKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkTransformMatrixKHR>(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + 1, dump_text_VkTransformMatrixKHR);  // AET
    dump_text_value<const uint32_t>(object.instanceCustomIndex, settings, "uint32_t instanceCustomIndex:24", "instanceCustomIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.mask, settings, "uint32_t mask:8", "mask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t instanceShaderBindingTableRecordOffset:24", "instanceShaderBindingTableRecordOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkGeometryInstanceFlagsKHR>(object.flags, settings, "VkGeometryInstanceFlagsKHR flags:8", "flags", indents + 1, dump_text_VkGeometryInstanceFlagsKHR);  // AET
    dump_text_value<const uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureCreateFlagsKHR>(object.createFlags, settings, "VkAccelerationStructureCreateFlagsKHR", "createFlags", indents + 1, dump_text_VkAccelerationStructureCreateFlagsKHR);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkAccelerationStructureTypeKHR>(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + 1, dump_text_VkAccelerationStructureTypeKHR);  // AET
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAccelerationStructureKHR>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "const VkAccelerationStructureKHR", "pAccelerationStructures", indents + 1, dump_text_VkAccelerationStructureKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.accelerationStructure, settings, "VkBool32", "accelerationStructure", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.accelerationStructureCaptureReplay, settings, "VkBool32", "accelerationStructureCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.accelerationStructureIndirectBuild, settings, "VkBool32", "accelerationStructureIndirectBuild", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.accelerationStructureHostCommands, settings, "VkBool32", "accelerationStructureHostCommands", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBindingAccelerationStructureUpdateAfterBind, settings, "VkBool32", "descriptorBindingAccelerationStructureUpdateAfterBind", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.maxPrimitiveCount, settings, "uint64_t", "maxPrimitiveCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorAccelerationStructures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPerStageDescriptorUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindAccelerationStructures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindAccelerationStructures", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minAccelerationStructureScratchOffsetAlignment, settings, "uint32_t", "minAccelerationStructureScratchOffsetAlignment", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureKHR>(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_array<const uint8_t>(object.pVersionData, 2*VK_UUID_SIZE, settings, "const uint8_t*", "const uint8_t", "pVersionData", indents + 1, dump_text_uint8_t); // BQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureKHR>(object.src, settings, "VkAccelerationStructureKHR", "src", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkDeviceOrHostAddressKHR>(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + 1, dump_text_VkDeviceOrHostAddressKHR);  // AET
    dump_text_value<const VkCopyAccelerationStructureModeKHR>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + 1, dump_text_VkCopyAccelerationStructureModeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkAccelerationStructureKHR>(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkCopyAccelerationStructureModeKHR>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + 1, dump_text_VkCopyAccelerationStructureModeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureKHR>(object.src, settings, "VkAccelerationStructureKHR", "src", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkAccelerationStructureKHR>(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkCopyAccelerationStructureModeKHR>(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + 1, dump_text_VkCopyAccelerationStructureModeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.accelerationStructureSize, settings, "VkDeviceSize", "accelerationStructureSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.updateScratchSize, settings, "VkDeviceSize", "updateScratchSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCoverageModulationStateCreateFlagsNV>(object.flags, settings, "VkPipelineCoverageModulationStateCreateFlagsNV", "flags", indents + 1, dump_text_VkPipelineCoverageModulationStateCreateFlagsNV);  // AET
    dump_text_value<const VkCoverageModulationModeNV>(object.coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", indents + 1, dump_text_VkCoverageModulationModeNV);  // AET
    dump_text_value<const VkBool32>(object.coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const float>(object.pCoverageModulationTable, object.coverageModulationTableCount, settings, "const float*", "const float", "pCoverageModulationTable", indents + 1, dump_text_float); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderSMCount, settings, "uint32_t", "shaderSMCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderWarpsPerSM, settings, "uint32_t", "shaderWarpsPerSM", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderSMBuiltins, settings, "VkBool32", "shaderSMBuiltins", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags", "drmFormatModifierTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
}
void dump_text_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDrmFormatModifierPropertiesEXT>(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierPropertiesEXT*", "VkDrmFormatModifierPropertiesEXT", "pDrmFormatModifierProperties", indents + 1, dump_text_VkDrmFormatModifierPropertiesEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkSharingMode>(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + 1, dump_text_VkSharingMode);  // AET
    dump_text_value<const uint32_t>(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "const uint32_t", "pQueueFamilyIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pDrmFormatModifiers, object.drmFormatModifierCount, settings, "const uint64_t*", "const uint64_t", "pDrmFormatModifiers", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSubresourceLayout>(object.pPlaneLayouts, object.drmFormatModifierPlaneCount, settings, "const VkSubresourceLayout*", "const VkSubresourceLayout", "pPlaneLayouts", indents + 1, dump_text_VkSubresourceLayout); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint64_t>(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormatFeatureFlags2>(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags2", "drmFormatModifierTilingFeatures", indents + 1, dump_text_VkFormatFeatureFlags2);  // AET
}
void dump_text_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDrmFormatModifierProperties2EXT>(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierProperties2EXT*", "VkDrmFormatModifierProperties2EXT", "pDrmFormatModifierProperties", indents + 1, dump_text_VkDrmFormatModifierProperties2EXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkValidationCacheCreateFlagsEXT>(object.flags, settings, "VkValidationCacheCreateFlagsEXT", "flags", indents + 1, dump_text_VkValidationCacheCreateFlagsEXT);  // AET
    dump_text_value<const size_t>(object.initialDataSize, settings, "size_t", "initialDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pInitialData, settings, "const void*", "pInitialData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkValidationCacheEXT>(object.validationCache, settings, "VkValidationCacheEXT", "validationCache", indents + 1, dump_text_VkValidationCacheEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.constantAlphaColorBlendFactors, settings, "VkBool32", "constantAlphaColorBlendFactors", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.events, settings, "VkBool32", "events", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.imageViewFormatReinterpretation, settings, "VkBool32", "imageViewFormatReinterpretation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.imageViewFormatSwizzle, settings, "VkBool32", "imageViewFormatSwizzle", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.imageView2DOn3DImage, settings, "VkBool32", "imageView2DOn3DImage", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multisampleArrayImage, settings, "VkBool32", "multisampleArrayImage", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.mutableComparisonSamplers, settings, "VkBool32", "mutableComparisonSamplers", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pointPolygons, settings, "VkBool32", "pointPolygons", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.samplerMipLodBias, settings, "VkBool32", "samplerMipLodBias", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.separateStencilMaskRef, settings, "VkBool32", "separateStencilMaskRef", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSampleRateInterpolationFunctions, settings, "VkBool32", "shaderSampleRateInterpolationFunctions", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tessellationIsolines, settings, "VkBool32", "tessellationIsolines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tessellationPointMode, settings, "VkBool32", "tessellationPointMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.triangleFans, settings, "VkBool32", "triangleFans", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.vertexAttributeAccessBeyondStride, settings, "VkBool32", "vertexAttributeAccessBeyondStride", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.minVertexInputBindingStrideAlignment, settings, "uint32_t", "minVertexInputBindingStrideAlignment", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkShadingRatePaletteNV(const VkShadingRatePaletteNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.shadingRatePaletteEntryCount, settings, "uint32_t", "shadingRatePaletteEntryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkShadingRatePaletteEntryNV>(object.pShadingRatePaletteEntries, object.shadingRatePaletteEntryCount, settings, "const VkShadingRatePaletteEntryNV*", "const VkShadingRatePaletteEntryNV", "pShadingRatePaletteEntries", indents + 1, dump_text_VkShadingRatePaletteEntryNV); // BQB
}
void dump_text_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.viewportCount, settings, "uint32_t", "viewportCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkShadingRatePaletteNV>(object.pShadingRatePalettes, object.viewportCount, settings, "const VkShadingRatePaletteNV*", "const VkShadingRatePaletteNV", "pShadingRatePalettes", indents + 1, dump_text_VkShadingRatePaletteNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shadingRateImage, settings, "VkBool32", "shadingRateImage", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shadingRateCoarseSampleOrder, settings, "VkBool32", "shadingRateCoarseSampleOrder", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.shadingRateTexelSize, settings, "VkExtent2D", "shadingRateTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.shadingRatePaletteSize, settings, "uint32_t", "shadingRatePaletteSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shadingRateMaxCoarseSamples, settings, "uint32_t", "shadingRateMaxCoarseSamples", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCoarseSampleLocationNV(const VkCoarseSampleLocationNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.pixelX, settings, "uint32_t", "pixelX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pixelY, settings, "uint32_t", "pixelY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sample, settings, "uint32_t", "sample", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkShadingRatePaletteEntryNV>(object.shadingRate, settings, "VkShadingRatePaletteEntryNV", "shadingRate", indents + 1, dump_text_VkShadingRatePaletteEntryNV);  // AET
    dump_text_value<const uint32_t>(object.sampleCount, settings, "uint32_t", "sampleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sampleLocationCount, settings, "uint32_t", "sampleLocationCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkCoarseSampleLocationNV>(object.pSampleLocations, object.sampleLocationCount, settings, "const VkCoarseSampleLocationNV*", "const VkCoarseSampleLocationNV", "pSampleLocations", indents + 1, dump_text_VkCoarseSampleLocationNV); // BQB
}
void dump_text_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCoarseSampleOrderTypeNV>(object.sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", indents + 1, dump_text_VkCoarseSampleOrderTypeNV);  // AET
    dump_text_value<const uint32_t>(object.customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkCoarseSampleOrderCustomNV>(object.pCustomSampleOrders, object.customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "const VkCoarseSampleOrderCustomNV", "pCustomSampleOrders", indents + 1, dump_text_VkCoarseSampleOrderCustomNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRayTracingShaderGroupTypeKHR>(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + 1, dump_text_VkRayTracingShaderGroupTypeKHR);  // AET
    dump_text_value<const uint32_t>(object.generalShader, settings, "uint32_t", "generalShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + 1, dump_text_VkPipelineCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineShaderStageCreateInfo>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "const VkPipelineShaderStageCreateInfo", "pStages", indents + 1, dump_text_VkPipelineShaderStageCreateInfo); // BQB
    dump_text_value<const uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRayTracingShaderGroupCreateInfoNV>(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoNV*", "const VkRayTracingShaderGroupCreateInfoNV", "pGroups", indents + 1, dump_text_VkRayTracingShaderGroupCreateInfoNV); // BQB
    dump_text_value<const uint32_t>(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkPipeline>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeometryTrianglesNV(const VkGeometryTrianglesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.vertexData, settings, "VkBuffer", "vertexData", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.vertexOffset, settings, "VkDeviceSize", "vertexOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkFormat>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkBuffer>(object.indexData, settings, "VkBuffer", "indexData", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.indexOffset, settings, "VkDeviceSize", "indexOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkBuffer>(object.transformData, settings, "VkBuffer", "transformData", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.transformOffset, settings, "VkDeviceSize", "transformOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeometryAABBNV(const VkGeometryAABBNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.aabbData, settings, "VkBuffer", "aabbData", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const uint32_t>(object.numAABBs, settings, "uint32_t", "numAABBs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeometryDataNV(const VkGeometryDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkGeometryTrianglesNV>(object.triangles, settings, "VkGeometryTrianglesNV", "triangles", indents + 1, dump_text_VkGeometryTrianglesNV);  // AET
    dump_text_value<const VkGeometryAABBNV>(object.aabbs, settings, "VkGeometryAABBNV", "aabbs", indents + 1, dump_text_VkGeometryAABBNV);  // AET
}
void dump_text_VkGeometryNV(const VkGeometryNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkGeometryTypeKHR>(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + 1, dump_text_VkGeometryTypeKHR);  // AET
    dump_text_value<const VkGeometryDataNV>(object.geometry, settings, "VkGeometryDataNV", "geometry", indents + 1, dump_text_VkGeometryDataNV);  // AET
    dump_text_value<const VkGeometryFlagsKHR>(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + 1, dump_text_VkGeometryFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureTypeNV>(object.type, settings, "VkAccelerationStructureTypeNV", "type", indents + 1, dump_text_VkAccelerationStructureTypeKHR);  // AET
    dump_text_value<const VkBuildAccelerationStructureFlagsNV>(object.flags, settings, "VkBuildAccelerationStructureFlagsNV", "flags", indents + 1, dump_text_VkBuildAccelerationStructureFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.geometryCount, settings, "uint32_t", "geometryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkGeometryNV>(object.pGeometries, object.geometryCount, settings, "const VkGeometryNV*", "const VkGeometryNV", "pGeometries", indents + 1, dump_text_VkGeometryNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.compactedSize, settings, "VkDeviceSize", "compactedSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkAccelerationStructureInfoNV>(object.info, settings, "VkAccelerationStructureInfoNV", "info", indents + 1, dump_text_VkAccelerationStructureInfoNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureNV>(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + 1, dump_text_VkAccelerationStructureNV);  // AET
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkDeviceSize>(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "const uint32_t", "pDeviceIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkAccelerationStructureNV>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "const VkAccelerationStructureNV", "pAccelerationStructures", indents + 1, dump_text_VkAccelerationStructureNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureMemoryRequirementsTypeNV>(object.type, settings, "VkAccelerationStructureMemoryRequirementsTypeNV", "type", indents + 1, dump_text_VkAccelerationStructureMemoryRequirementsTypeNV);  // AET
    dump_text_value<const VkAccelerationStructureNV>(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + 1, dump_text_VkAccelerationStructureNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint64_t>(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.maxTriangleCount, settings, "uint64_t", "maxTriangleCount", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.representativeFragmentTest, settings, "VkBool32", "representativeFragmentTest", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageViewType>(object.imageViewType, settings, "VkImageViewType", "imageViewType", indents + 1, dump_text_VkImageViewType);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.filterCubic, settings, "VkBool32", "filterCubic", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.filterCubicMinmax, settings, "VkBool32", "filterCubicMinmax", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    dump_text_value<const void*>(object.pHostPointer, settings, "void*", "pHostPointer", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.minImportedHostPointerAlignment, settings, "VkDeviceSize", "minImportedHostPointerAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderSubgroupClock, settings, "VkBool32", "shaderSubgroupClock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderDeviceClock, settings, "VkBool32", "shaderDeviceClock", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCompilerControlFlagsAMD>(object.compilerControlFlags, settings, "VkPipelineCompilerControlFlagsAMD", "compilerControlFlags", indents + 1, dump_text_VkPipelineCompilerControlFlagsAMD);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkTimeDomainKHR>(object.timeDomain, settings, "VkTimeDomainKHR", "timeDomain", indents + 1, dump_text_VkTimeDomainKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderEngineCount, settings, "uint32_t", "shaderEngineCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderArraysPerEngineCount, settings, "uint32_t", "shaderArraysPerEngineCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.computeUnitsPerShaderArray, settings, "uint32_t", "computeUnitsPerShaderArray", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.simdPerComputeUnit, settings, "uint32_t", "simdPerComputeUnit", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.wavefrontsPerSimd, settings, "uint32_t", "wavefrontsPerSimd", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.wavefrontSize, settings, "uint32_t", "wavefrontSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sgprsPerSimd, settings, "uint32_t", "sgprsPerSimd", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minSgprAllocation, settings, "uint32_t", "minSgprAllocation", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSgprAllocation, settings, "uint32_t", "maxSgprAllocation", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sgprAllocationGranularity, settings, "uint32_t", "sgprAllocationGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vgprsPerSimd, settings, "uint32_t", "vgprsPerSimd", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minVgprAllocation, settings, "uint32_t", "minVgprAllocation", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxVgprAllocation, settings, "uint32_t", "maxVgprAllocation", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vgprAllocationGranularity, settings, "uint32_t", "vgprAllocationGranularity", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoH265ProfileIdc>(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + 1, dump_text_StdVideoH265ProfileIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const StdVideoH265LevelIdc>(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + 1, dump_text_StdVideoH265LevelIdc);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265VideoParameterSet>(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "const StdVideoH265VideoParameterSet", "pStdVPSs", indents + 1, dump_text_StdVideoH265VideoParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265SequenceParameterSet>(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "const StdVideoH265SequenceParameterSet", "pStdSPSs", indents + 1, dump_text_StdVideoH265SequenceParameterSet); // BQB
    dump_text_value<const uint32_t>(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoH265PictureParameterSet>(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "const StdVideoH265PictureParameterSet", "pStdPPSs", indents + 1, dump_text_StdVideoH265PictureParameterSet); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkVideoDecodeH265SessionParametersAddInfoKHR>(object.pParametersAddInfo, settings, "const VkVideoDecodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + 1, dump_text_VkVideoDecodeH265SessionParametersAddInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeH265PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoDecodeH265PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoDecodeH265PictureInfo);
    dump_text_value<const uint32_t>(object.sliceSegmentCount, settings, "uint32_t", "sliceSegmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pSliceSegmentOffsets, object.sliceSegmentCount, settings, "const uint32_t*", "const uint32_t", "pSliceSegmentOffsets", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeH265ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoDecodeH265ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoDecodeH265ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMemoryOverallocationBehaviorAMD>(object.overallocationBehavior, settings, "VkMemoryOverallocationBehaviorAMD", "overallocationBehavior", indents + 1, dump_text_VkMemoryOverallocationBehaviorAMD);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const GgpFrameToken>(object.frameToken, settings, "GgpFrameToken", "frameToken", indents + 1, dump_text_GgpFrameToken);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_GGP
void dump_text_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.computeDerivativeGroupQuads, settings, "VkBool32", "computeDerivativeGroupQuads", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.computeDerivativeGroupLinear, settings, "VkBool32", "computeDerivativeGroupLinear", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.taskShader, settings, "VkBool32", "taskShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.meshShader, settings, "VkBool32", "meshShader", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxDrawMeshTasksCount, settings, "uint32_t", "maxDrawMeshTasksCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxTaskWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxTaskTotalMemorySize, settings, "uint32_t", "maxTaskTotalMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTaskOutputCount, settings, "uint32_t", "maxTaskOutputCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxMeshWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxMeshTotalMemorySize, settings, "uint32_t", "maxMeshTotalMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.taskCount, settings, "uint32_t", "taskCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.firstTask, settings, "uint32_t", "firstTask", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentShaderBarycentric, settings, "VkBool32", "fragmentShaderBarycentric", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imageFootprint, settings, "VkBool32", "imageFootprint", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pExclusiveScissors, object.exclusiveScissorCount, settings, "const VkRect2D*", "const VkRect2D", "pExclusiveScissors", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.exclusiveScissor, settings, "VkBool32", "exclusiveScissor", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineStageFlags>(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags", "checkpointExecutionStageMask", indents + 1, dump_text_VkPipelineStageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCheckpointDataNV(const VkCheckpointDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineStageFlagBits>(object.stage, settings, "VkPipelineStageFlagBits", "stage", indents + 1, dump_text_VkPipelineStageFlagBits);  // AET
    dump_text_value<const void*>(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineStageFlags2>(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags2", "checkpointExecutionStageMask", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCheckpointData2NV(const VkCheckpointData2NV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineStageFlags2>(object.stage, settings, "VkPipelineStageFlags2", "stage", indents + 1, dump_text_VkPipelineStageFlags2);  // AET
    dump_text_value<const void*>(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderIntegerFunctions2, settings, "VkBool32", "shaderIntegerFunctions2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceValueINTEL(const VkPerformanceValueINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkPerformanceValueTypeINTEL>(object.type, settings, "VkPerformanceValueTypeINTEL", "type", indents + 1, dump_text_VkPerformanceValueTypeINTEL);  // AET
    dump_text_value<const VkPerformanceValueDataINTEL>(object.data, settings, "VkPerformanceValueDataINTEL", "data", indents + 1, dump_text_VkPerformanceValueDataINTEL);  // AET
}
void dump_text_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.pUserData, settings, "void*", "pUserData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueryPoolSamplingModeINTEL>(object.performanceCountersSampling, settings, "VkQueryPoolSamplingModeINTEL", "performanceCountersSampling", indents + 1, dump_text_VkQueryPoolSamplingModeINTEL);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.marker, settings, "uint64_t", "marker", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.marker, settings, "uint32_t", "marker", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPerformanceOverrideTypeINTEL>(object.type, settings, "VkPerformanceOverrideTypeINTEL", "type", indents + 1, dump_text_VkPerformanceOverrideTypeINTEL);  // AET
    dump_text_value<const VkBool32>(object.enable, settings, "VkBool32", "enable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint64_t>(object.parameter, settings, "uint64_t", "parameter", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPerformanceConfigurationTypeINTEL>(object.type, settings, "VkPerformanceConfigurationTypeINTEL", "type", indents + 1, dump_text_VkPerformanceConfigurationTypeINTEL);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.pciDomain, settings, "uint32_t", "pciDomain", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pciBus, settings, "uint32_t", "pciBus", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pciDevice, settings, "uint32_t", "pciDevice", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pciFunction, settings, "uint32_t", "pciFunction", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.localDimmingSupport, settings, "VkBool32", "localDimmingSupport", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.localDimmingEnable, settings, "VkBool32", "localDimmingEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImagePipeSurfaceCreateFlagsFUCHSIA>(object.flags, settings, "VkImagePipeSurfaceCreateFlagsFUCHSIA", "flags", indents + 1, dump_text_VkImagePipeSurfaceCreateFlagsFUCHSIA);  // AET
    dump_text_value<const zx_handle_t>(object.imagePipeHandle, settings, "zx_handle_t", "imagePipeHandle", indents + 1, dump_text_zx_handle_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMetalSurfaceCreateFlagsEXT>(object.flags, settings, "VkMetalSurfaceCreateFlagsEXT", "flags", indents + 1, dump_text_VkMetalSurfaceCreateFlagsEXT);  // AET
    dump_text_pointer<const CAMetalLayer>(object.pLayer, settings, "const CAMetalLayer*", "pLayer", indents + 1, dump_text_CAMetalLayer);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentDensityMap, settings, "VkBool32", "fragmentDensityMap", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentDensityMapDynamic, settings, "VkBool32", "fragmentDensityMapDynamic", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentDensityMapNonSubsampledImages, settings, "VkBool32", "fragmentDensityMapNonSubsampledImages", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.minFragmentDensityTexelSize, settings, "VkExtent2D", "minFragmentDensityTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxFragmentDensityTexelSize, settings, "VkExtent2D", "maxFragmentDensityTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkBool32>(object.fragmentDensityInvocations, settings, "VkBool32", "fragmentDensityInvocations", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAttachmentReference>(object.fragmentDensityMapAttachment, settings, "VkAttachmentReference", "fragmentDensityMapAttachment", indents + 1, dump_text_VkAttachmentReference);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkImageLayout>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkAttachmentReference2>(object.pFragmentShadingRateAttachment, settings, "const VkAttachmentReference2*", "pFragmentShadingRateAttachment", indents + 1, dump_text_VkAttachmentReference2);
    dump_text_value<const VkExtent2D>(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExtent2D>(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_array<const VkFragmentShadingRateCombinerOpKHR>(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "VkFragmentShadingRateCombinerOpKHR", "combinerOps", indents + 1, dump_text_VkFragmentShadingRateCombinerOpKHR); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineFragmentShadingRate, settings, "VkBool32", "pipelineFragmentShadingRate", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.primitiveFragmentShadingRate, settings, "VkBool32", "primitiveFragmentShadingRate", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.attachmentFragmentShadingRate, settings, "VkBool32", "attachmentFragmentShadingRate", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.minFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "minFragmentShadingRateAttachmentTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "maxFragmentShadingRateAttachmentTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, settings, "uint32_t", "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.primitiveFragmentShadingRateWithMultipleViewports, settings, "VkBool32", "primitiveFragmentShadingRateWithMultipleViewports", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.layeredShadingRateAttachments, settings, "VkBool32", "layeredShadingRateAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateNonTrivialCombinerOps, settings, "VkBool32", "fragmentShadingRateNonTrivialCombinerOps", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkExtent2D>(object.maxFragmentSize, settings, "VkExtent2D", "maxFragmentSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentSizeAspectRatio, settings, "uint32_t", "maxFragmentSizeAspectRatio", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxFragmentShadingRateCoverageSamples, settings, "uint32_t", "maxFragmentShadingRateCoverageSamples", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.maxFragmentShadingRateRasterizationSamples, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateRasterizationSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithShaderDepthStencilWrites, settings, "VkBool32", "fragmentShadingRateWithShaderDepthStencilWrites", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithSampleMask, settings, "VkBool32", "fragmentShadingRateWithSampleMask", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithShaderSampleMask, settings, "VkBool32", "fragmentShadingRateWithShaderSampleMask", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithConservativeRasterization, settings, "VkBool32", "fragmentShadingRateWithConservativeRasterization", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithFragmentShaderInterlock, settings, "VkBool32", "fragmentShadingRateWithFragmentShaderInterlock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateWithCustomSampleLocations, settings, "VkBool32", "fragmentShadingRateWithCustomSampleLocations", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShadingRateStrictMultiplyCombiner, settings, "VkBool32", "fragmentShadingRateStrictMultiplyCombiner", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSampleCountFlags>(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkExtent2D>(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkImageLayout>(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + 1, dump_text_VkImageLayout);  // AET
    dump_text_value<const VkExtent2D>(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderCorePropertiesFlagsAMD>(object.shaderCoreFeatures, settings, "VkShaderCorePropertiesFlagsAMD", "shaderCoreFeatures", indents + 1, dump_text_VkShaderCorePropertiesFlagsAMD);  // AET
    dump_text_value<const uint32_t>(object.activeComputeUnitCount, settings, "uint32_t", "activeComputeUnitCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceCoherentMemory, settings, "VkBool32", "deviceCoherentMemory", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderImageInt64Atomics, settings, "VkBool32", "shaderImageInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseImageInt64Atomics, settings, "VkBool32", "sparseImageInt64Atomics", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderQuadControl, settings, "VkBool32", "shaderQuadControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const VkDeviceSize>(object.heapBudget, ApiDumpInstance::current().getMemoryHeapCount(), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "VkDeviceSize", "heapBudget", indents + 1, dump_text_VkDeviceSize); // BQA
    dump_text_array<const VkDeviceSize>(object.heapUsage, ApiDumpInstance::current().getMemoryHeapCount(), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "VkDeviceSize", "heapUsage", indents + 1, dump_text_VkDeviceSize); // BQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.memoryPriority, settings, "VkBool32", "memoryPriority", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const float>(object.priority, settings, "float", "priority", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.supportsProtected, settings, "VkBool32", "supportsProtected", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.dedicatedAllocationImageAliasing, settings, "VkBool32", "dedicatedAllocationImageAliasing", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkValidationFeaturesEXT(const VkValidationFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.enabledValidationFeatureCount, settings, "uint32_t", "enabledValidationFeatureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkValidationFeatureEnableEXT>(object.pEnabledValidationFeatures, object.enabledValidationFeatureCount, settings, "const VkValidationFeatureEnableEXT*", "const VkValidationFeatureEnableEXT", "pEnabledValidationFeatures", indents + 1, dump_text_VkValidationFeatureEnableEXT); // BQB
    dump_text_value<const uint32_t>(object.disabledValidationFeatureCount, settings, "uint32_t", "disabledValidationFeatureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkValidationFeatureDisableEXT>(object.pDisabledValidationFeatures, object.disabledValidationFeatureCount, settings, "const VkValidationFeatureDisableEXT*", "const VkValidationFeatureDisableEXT", "pDisabledValidationFeatures", indents + 1, dump_text_VkValidationFeatureDisableEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentWait, settings, "VkBool32", "presentWait", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.MSize, settings, "uint32_t", "MSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.NSize, settings, "uint32_t", "NSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.KSize, settings, "uint32_t", "KSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkComponentTypeNV>(object.AType, settings, "VkComponentTypeNV", "AType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeNV>(object.BType, settings, "VkComponentTypeNV", "BType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeNV>(object.CType, settings, "VkComponentTypeNV", "CType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeNV>(object.DType, settings, "VkComponentTypeNV", "DType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkScopeNV>(object.scope, settings, "VkScopeNV", "scope", indents + 1, dump_text_VkScopeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderStageFlags>(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.coverageReductionMode, settings, "VkBool32", "coverageReductionMode", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCoverageReductionStateCreateFlagsNV>(object.flags, settings, "VkPipelineCoverageReductionStateCreateFlagsNV", "flags", indents + 1, dump_text_VkPipelineCoverageReductionStateCreateFlagsNV);  // AET
    dump_text_value<const VkCoverageReductionModeNV>(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + 1, dump_text_VkCoverageReductionModeNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkCoverageReductionModeNV>(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + 1, dump_text_VkCoverageReductionModeNV);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    dump_text_value<const VkSampleCountFlags>(object.depthStencilSamples, settings, "VkSampleCountFlags", "depthStencilSamples", indents + 1, dump_text_VkSampleCountFlags);  // AET
    dump_text_value<const VkSampleCountFlags>(object.colorSamples, settings, "VkSampleCountFlags", "colorSamples", indents + 1, dump_text_VkSampleCountFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentShaderSampleInterlock, settings, "VkBool32", "fragmentShaderSampleInterlock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShaderPixelInterlock, settings, "VkBool32", "fragmentShaderPixelInterlock", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.fragmentShaderShadingRateInterlock, settings, "VkBool32", "fragmentShaderShadingRateInterlock", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.ycbcrImageArrays, settings, "VkBool32", "ycbcrImageArrays", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.provokingVertexLast, settings, "VkBool32", "provokingVertexLast", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackPreservesProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesProvokingVertex", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.provokingVertexModePerPipeline, settings, "VkBool32", "provokingVertexModePerPipeline", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.transformFeedbackPreservesTriangleFanProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesTriangleFanProvokingVertex", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkProvokingVertexModeEXT>(object.provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", indents + 1, dump_text_VkProvokingVertexModeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFullScreenExclusiveEXT>(object.fullScreenExclusive, settings, "VkFullScreenExclusiveEXT", "fullScreenExclusive", indents + 1, dump_text_VkFullScreenExclusiveEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fullScreenExclusiveSupported, settings, "VkBool32", "fullScreenExclusiveSupported", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const HMONITOR>(object.hmonitor, settings, "HMONITOR", "hmonitor", indents + 1, dump_text_HMONITOR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkHeadlessSurfaceCreateFlagsEXT>(object.flags, settings, "VkHeadlessSurfaceCreateFlagsEXT", "flags", indents + 1, dump_text_VkHeadlessSurfaceCreateFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderBufferFloat32Atomics, settings, "VkBool32", "shaderBufferFloat32Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat32AtomicAdd, settings, "VkBool32", "shaderBufferFloat32AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat64Atomics, settings, "VkBool32", "shaderBufferFloat64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat64AtomicAdd, settings, "VkBool32", "shaderBufferFloat64AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat32Atomics, settings, "VkBool32", "shaderSharedFloat32Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat32AtomicAdd, settings, "VkBool32", "shaderSharedFloat32AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat64Atomics, settings, "VkBool32", "shaderSharedFloat64Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat64AtomicAdd, settings, "VkBool32", "shaderSharedFloat64AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderImageFloat32Atomics, settings, "VkBool32", "shaderImageFloat32Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderImageFloat32AtomicAdd, settings, "VkBool32", "shaderImageFloat32AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseImageFloat32Atomics, settings, "VkBool32", "sparseImageFloat32Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseImageFloat32AtomicAdd, settings, "VkBool32", "sparseImageFloat32AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.extendedDynamicState, settings, "VkBool32", "extendedDynamicState", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineExecutableInfo, settings, "VkBool32", "pipelineExecutableInfo", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineInfoKHR(const VkPipelineInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderStageFlags>(object.stages, settings, "VkShaderStageFlags", "stages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const char*>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const uint32_t>(object.executableIndex, settings, "uint32_t", "executableIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const char*>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkPipelineExecutableStatisticFormatKHR>(object.format, settings, "VkPipelineExecutableStatisticFormatKHR", "format", indents + 1, dump_text_VkPipelineExecutableStatisticFormatKHR);  // AET
    dump_text_value<const VkPipelineExecutableStatisticValueKHR>(object.value, settings, "VkPipelineExecutableStatisticValueKHR", "value", indents + 1, dump_text_VkPipelineExecutableStatisticValueKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const char*>(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkBool32>(object.isText, settings, "VkBool32", "isText", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const size_t>(object.dataSize, settings, "size_t", "dataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "void*", "pData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.memoryMapPlaced, settings, "VkBool32", "memoryMapPlaced", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.memoryMapRangePlaced, settings, "VkBool32", "memoryMapRangePlaced", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.memoryUnmapReserve, settings, "VkBool32", "memoryUnmapReserve", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.minPlacedMemoryMapAlignment, settings, "VkDeviceSize", "minPlacedMemoryMapAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.pPlacedAddress, settings, "void*", "pPlacedAddress", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderBufferFloat16Atomics, settings, "VkBool32", "shaderBufferFloat16Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat16AtomicAdd, settings, "VkBool32", "shaderBufferFloat16AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat16AtomicMinMax, settings, "VkBool32", "shaderBufferFloat16AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat32AtomicMinMax, settings, "VkBool32", "shaderBufferFloat32AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderBufferFloat64AtomicMinMax, settings, "VkBool32", "shaderBufferFloat64AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat16Atomics, settings, "VkBool32", "shaderSharedFloat16Atomics", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat16AtomicAdd, settings, "VkBool32", "shaderSharedFloat16AtomicAdd", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat16AtomicMinMax, settings, "VkBool32", "shaderSharedFloat16AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat32AtomicMinMax, settings, "VkBool32", "shaderSharedFloat32AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderSharedFloat64AtomicMinMax, settings, "VkBool32", "shaderSharedFloat64AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderImageFloat32AtomicMinMax, settings, "VkBool32", "shaderImageFloat32AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sparseImageFloat32AtomicMinMax, settings, "VkBool32", "sparseImageFloat32AtomicMinMax", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPresentModeKHR>(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + 1, dump_text_VkPresentModeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfacePresentScalingCapabilitiesEXT(const VkSurfacePresentScalingCapabilitiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPresentScalingFlagsEXT>(object.supportedPresentScaling, settings, "VkPresentScalingFlagsEXT", "supportedPresentScaling", indents + 1, dump_text_VkPresentScalingFlagsEXT);  // AET
    dump_text_value<const VkPresentGravityFlagsEXT>(object.supportedPresentGravityX, settings, "VkPresentGravityFlagsEXT", "supportedPresentGravityX", indents + 1, dump_text_VkPresentGravityFlagsEXT);  // AET
    dump_text_value<const VkPresentGravityFlagsEXT>(object.supportedPresentGravityY, settings, "VkPresentGravityFlagsEXT", "supportedPresentGravityY", indents + 1, dump_text_VkPresentGravityFlagsEXT);  // AET
    dump_text_value<const VkExtent2D>(object.minScaledImageExtent, settings, "VkExtent2D", "minScaledImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxScaledImageExtent, settings, "VkExtent2D", "maxScaledImageExtent", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentModeKHR>(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "VkPresentModeKHR", "pPresentModes", indents + 1, dump_text_VkPresentModeKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.swapchainMaintenance1, settings, "VkBool32", "swapchainMaintenance1", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkFence>(object.pFences, object.swapchainCount, settings, "const VkFence*", "const VkFence", "pFences", indents + 1, dump_text_VkFence); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentModeKHR>(object.pPresentModes, object.presentModeCount, settings, "const VkPresentModeKHR*", "const VkPresentModeKHR", "pPresentModes", indents + 1, dump_text_VkPresentModeKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentModeKHR>(object.pPresentModes, object.swapchainCount, settings, "const VkPresentModeKHR*", "const VkPresentModeKHR", "pPresentModes", indents + 1, dump_text_VkPresentModeKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainPresentScalingCreateInfoEXT(const VkSwapchainPresentScalingCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPresentScalingFlagsEXT>(object.scalingBehavior, settings, "VkPresentScalingFlagsEXT", "scalingBehavior", indents + 1, dump_text_VkPresentScalingFlagsEXT);  // AET
    dump_text_value<const VkPresentGravityFlagsEXT>(object.presentGravityX, settings, "VkPresentGravityFlagsEXT", "presentGravityX", indents + 1, dump_text_VkPresentGravityFlagsEXT);  // AET
    dump_text_value<const VkPresentGravityFlagsEXT>(object.presentGravityY, settings, "VkPresentGravityFlagsEXT", "presentGravityY", indents + 1, dump_text_VkPresentGravityFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSwapchainKHR>(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + 1, dump_text_VkSwapchainKHR);  // AET
    dump_text_value<const uint32_t>(object.imageIndexCount, settings, "uint32_t", "imageIndexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pImageIndices, object.imageIndexCount, settings, "const uint32_t*", "const uint32_t", "pImageIndices", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxGraphicsShaderGroupCount, settings, "uint32_t", "maxGraphicsShaderGroupCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsStreamCount, settings, "uint32_t", "maxIndirectCommandsStreamCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsStreamStride, settings, "uint32_t", "maxIndirectCommandsStreamStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minSequencesCountBufferOffsetAlignment, settings, "uint32_t", "minSequencesCountBufferOffsetAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minSequencesIndexBufferOffsetAlignment, settings, "uint32_t", "minSequencesIndexBufferOffsetAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minIndirectCommandsBufferOffsetAlignment, settings, "uint32_t", "minIndirectCommandsBufferOffsetAlignment", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineShaderStageCreateInfo>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "const VkPipelineShaderStageCreateInfo", "pStages", indents + 1, dump_text_VkPipelineShaderStageCreateInfo); // BQB
    dump_text_pointer<const VkPipelineVertexInputStateCreateInfo>(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + 1, dump_text_VkPipelineVertexInputStateCreateInfo);
    dump_text_pointer<const VkPipelineTessellationStateCreateInfo>(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + 1, dump_text_VkPipelineTessellationStateCreateInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkGraphicsShaderGroupCreateInfoNV>(object.pGroups, object.groupCount, settings, "const VkGraphicsShaderGroupCreateInfoNV*", "const VkGraphicsShaderGroupCreateInfoNV", "pGroups", indents + 1, dump_text_VkGraphicsShaderGroupCreateInfoNV); // BQB
    dump_text_value<const uint32_t>(object.pipelineCount, settings, "uint32_t", "pipelineCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipeline>(object.pPipelines, object.pipelineCount, settings, "const VkPipeline*", "const VkPipeline", "pPipelines", indents + 1, dump_text_VkPipeline); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindShaderGroupIndirectCommandNV(const VkBindShaderGroupIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.groupIndex, settings, "uint32_t", "groupIndex", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkBindIndexBufferIndirectCommandNV(const VkBindIndexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
}
void dump_text_VkBindVertexBufferIndirectCommandNV(const VkBindVertexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkSetStateFlagsIndirectCommandNV(const VkSetStateFlagsIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.data, settings, "uint32_t", "data", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkIndirectCommandsStreamNV(const VkIndirectCommandsStreamNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectCommandsTokenTypeNV>(object.tokenType, settings, "VkIndirectCommandsTokenTypeNV", "tokenType", indents + 1, dump_text_VkIndirectCommandsTokenTypeNV);  // AET
    dump_text_value<const uint32_t>(object.stream, settings, "uint32_t", "stream", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.vertexDynamicStride, settings, "VkBool32", "vertexDynamicStride", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkPipelineLayout>(object.pushconstantPipelineLayout, settings, "VkPipelineLayout", "pushconstantPipelineLayout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkShaderStageFlags>(object.pushconstantShaderStageFlags, settings, "VkShaderStageFlags", "pushconstantShaderStageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const uint32_t>(object.pushconstantOffset, settings, "uint32_t", "pushconstantOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pushconstantSize, settings, "uint32_t", "pushconstantSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndirectStateFlagsNV>(object.indirectStateFlags, settings, "VkIndirectStateFlagsNV", "indirectStateFlags", indents + 1, dump_text_VkIndirectStateFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.indexTypeCount, settings, "uint32_t", "indexTypeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkIndexType>(object.pIndexTypes, object.indexTypeCount, settings, "const VkIndexType*", "const VkIndexType", "pIndexTypes", indents + 1, dump_text_VkIndexType); // BQB
    dump_text_array<const uint32_t>(object.pIndexTypeValues, object.indexTypeCount, settings, "const uint32_t*", "const uint32_t", "pIndexTypeValues", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectCommandsLayoutUsageFlagsNV>(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsNV", "flags", indents + 1, dump_text_VkIndirectCommandsLayoutUsageFlagsNV);  // AET
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const uint32_t>(object.tokenCount, settings, "uint32_t", "tokenCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkIndirectCommandsLayoutTokenNV>(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenNV*", "const VkIndirectCommandsLayoutTokenNV", "pTokens", indents + 1, dump_text_VkIndirectCommandsLayoutTokenNV); // BQB
    dump_text_value<const uint32_t>(object.streamCount, settings, "uint32_t", "streamCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pStreamStrides, object.streamCount, settings, "const uint32_t*", "const uint32_t", "pStreamStrides", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const VkIndirectCommandsLayoutNV>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + 1, dump_text_VkIndirectCommandsLayoutNV);  // AET
    dump_text_value<const uint32_t>(object.streamCount, settings, "uint32_t", "streamCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkIndirectCommandsStreamNV>(object.pStreams, object.streamCount, settings, "const VkIndirectCommandsStreamNV*", "const VkIndirectCommandsStreamNV", "pStreams", indents + 1, dump_text_VkIndirectCommandsStreamNV); // BQB
    dump_text_value<const uint32_t>(object.sequencesCount, settings, "uint32_t", "sequencesCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBuffer>(object.preprocessBuffer, settings, "VkBuffer", "preprocessBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.preprocessOffset, settings, "VkDeviceSize", "preprocessOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBuffer>(object.sequencesCountBuffer, settings, "VkBuffer", "sequencesCountBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.sequencesCountOffset, settings, "VkDeviceSize", "sequencesCountOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBuffer>(object.sequencesIndexBuffer, settings, "VkBuffer", "sequencesIndexBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.sequencesIndexOffset, settings, "VkDeviceSize", "sequencesIndexOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const VkIndirectCommandsLayoutNV>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + 1, dump_text_VkIndirectCommandsLayoutNV);  // AET
    dump_text_value<const uint32_t>(object.maxSequencesCount, settings, "uint32_t", "maxSequencesCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.inheritedViewportScissor2D, settings, "VkBool32", "inheritedViewportScissor2D", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.viewportScissor2D, settings, "VkBool32", "viewportScissor2D", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.viewportDepthCount, settings, "uint32_t", "viewportDepthCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkViewport>(object.pViewportDepths, settings, "const VkViewport*", "pViewportDepths", indents + 1, dump_text_VkViewport);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.texelBufferAlignment, settings, "VkBool32", "texelBufferAlignment", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    dump_text_value<const VkRect2D>(object.renderArea, settings, "VkRect2D", "renderArea", indents + 1, dump_text_VkRect2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.depthBiasControl, settings, "VkBool32", "depthBiasControl", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.leastRepresentableValueForceUnormRepresentation, settings, "VkBool32", "leastRepresentableValueForceUnormRepresentation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.floatRepresentation, settings, "VkBool32", "floatRepresentation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const float>(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDepthBiasRepresentationEXT>(object.depthBiasRepresentation, settings, "VkDepthBiasRepresentationEXT", "depthBiasRepresentation", indents + 1, dump_text_VkDepthBiasRepresentationEXT);  // AET
    dump_text_value<const VkBool32>(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceMemoryReport, settings, "VkBool32", "deviceMemoryReport", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceMemoryReportFlagsEXT>(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + 1, dump_text_VkDeviceMemoryReportFlagsEXT);  // AET
    dump_text_value<const VkDeviceMemoryReportEventTypeEXT>(object.type, settings, "VkDeviceMemoryReportEventTypeEXT", "type", indents + 1, dump_text_VkDeviceMemoryReportEventTypeEXT);  // AET
    dump_text_value<const uint64_t>(object.memoryObjectId, settings, "uint64_t", "memoryObjectId", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkObjectType>(object.objectType, settings, "VkObjectType", "objectType", indents + 1, dump_text_VkObjectType);  // AET
    dump_text_value<const uint64_t>(object.objectHandle, settings, "uint64_t", "objectHandle", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.heapIndex, settings, "uint32_t", "heapIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemoryReportFlagsEXT>(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + 1, dump_text_VkDeviceMemoryReportFlagsEXT);  // AET
    dump_text_value<const PFN_vkDeviceMemoryReportCallbackEXT>(object.pfnUserCallback, settings, "PFN_vkDeviceMemoryReportCallbackEXT", "pfnUserCallback", indents + 1, dump_text_PFN_vkDeviceMemoryReportCallbackEXT);  // AET
    dump_text_value<const void*>(object.pUserData, settings, "void*", "pUserData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.robustBufferAccess2, settings, "VkBool32", "robustBufferAccess2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.robustImageAccess2, settings, "VkBool32", "robustImageAccess2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nullDescriptor, settings, "VkBool32", "nullDescriptor", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.robustStorageBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustStorageBufferAccessSizeAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.robustUniformBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustUniformBufferAccessSizeAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkClearColorValue>(object.customBorderColor, settings, "VkClearColorValue", "customBorderColor", indents + 1, dump_text_VkClearColorValue);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxCustomBorderColorSamplers, settings, "uint32_t", "maxCustomBorderColorSamplers", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.customBorderColors, settings, "VkBool32", "customBorderColors", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.customBorderColorWithoutFormat, settings, "VkBool32", "customBorderColorWithoutFormat", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentBarrier, settings, "VkBool32", "presentBarrier", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentBarrierSupported, settings, "VkBool32", "presentBarrierSupported", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentBarrierEnable, settings, "VkBool32", "presentBarrierEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPresentIdKHR(const VkPresentIdKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint64_t>(object.pPresentIds, object.swapchainCount, settings, "const uint64_t*", "const uint64_t", "pPresentIds", indents + 1, dump_text_uint64_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentId, settings, "VkBool32", "presentId", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeFlagsKHR>(object.flags, settings, "VkVideoEncodeFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeFlagsKHR);  // AET
    dump_text_value<const VkBuffer>(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.dstBufferOffset, settings, "VkDeviceSize", "dstBufferOffset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.dstBufferRange, settings, "VkDeviceSize", "dstBufferRange", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkVideoPictureResourceInfoKHR>(object.srcPictureResource, settings, "VkVideoPictureResourceInfoKHR", "srcPictureResource", indents + 1, dump_text_VkVideoPictureResourceInfoKHR);  // AET
    dump_text_pointer<const VkVideoReferenceSlotInfoKHR>(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + 1, dump_text_VkVideoReferenceSlotInfoKHR);
    dump_text_value<const uint32_t>(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoReferenceSlotInfoKHR>(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "const VkVideoReferenceSlotInfoKHR", "pReferenceSlots", indents + 1, dump_text_VkVideoReferenceSlotInfoKHR); // BQB
    dump_text_value<const uint32_t>(object.precedingExternallyEncodedBytes, settings, "uint32_t", "precedingExternallyEncodedBytes", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeCapabilityFlagsKHR>(object.flags, settings, "VkVideoEncodeCapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeCapabilityFlagsKHR);  // AET
    dump_text_value<const VkVideoEncodeRateControlModeFlagsKHR>(object.rateControlModes, settings, "VkVideoEncodeRateControlModeFlagsKHR", "rateControlModes", indents + 1, dump_text_VkVideoEncodeRateControlModeFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.maxRateControlLayers, settings, "uint32_t", "maxRateControlLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint64_t>(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.maxQualityLevels, settings, "uint32_t", "maxQualityLevels", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent2D>(object.encodeInputPictureGranularity, settings, "VkExtent2D", "encodeInputPictureGranularity", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkVideoEncodeFeedbackFlagsKHR>(object.supportedEncodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "supportedEncodeFeedbackFlags", indents + 1, dump_text_VkVideoEncodeFeedbackFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeFeedbackFlagsKHR>(object.encodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "encodeFeedbackFlags", indents + 1, dump_text_VkVideoEncodeFeedbackFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeUsageFlagsKHR>(object.videoUsageHints, settings, "VkVideoEncodeUsageFlagsKHR", "videoUsageHints", indents + 1, dump_text_VkVideoEncodeUsageFlagsKHR);  // AET
    dump_text_value<const VkVideoEncodeContentFlagsKHR>(object.videoContentHints, settings, "VkVideoEncodeContentFlagsKHR", "videoContentHints", indents + 1, dump_text_VkVideoEncodeContentFlagsKHR);  // AET
    dump_text_value<const VkVideoEncodeTuningModeKHR>(object.tuningMode, settings, "VkVideoEncodeTuningModeKHR", "tuningMode", indents + 1, dump_text_VkVideoEncodeTuningModeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.averageBitrate, settings, "uint64_t", "averageBitrate", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.frameRateNumerator, settings, "uint32_t", "frameRateNumerator", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.frameRateDenominator, settings, "uint32_t", "frameRateDenominator", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeRateControlFlagsKHR>(object.flags, settings, "VkVideoEncodeRateControlFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeRateControlFlagsKHR);  // AET
    dump_text_value<const VkVideoEncodeRateControlModeFlagBitsKHR>(object.rateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "rateControlMode", indents + 1, dump_text_VkVideoEncodeRateControlModeFlagBitsKHR);  // AET
    dump_text_value<const uint32_t>(object.layerCount, settings, "uint32_t", "layerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkVideoEncodeRateControlLayerInfoKHR>(object.pLayers, object.layerCount, settings, "const VkVideoEncodeRateControlLayerInfoKHR*", "const VkVideoEncodeRateControlLayerInfoKHR", "pLayers", indents + 1, dump_text_VkVideoEncodeRateControlLayerInfoKHR); // BQB
    dump_text_value<const uint32_t>(object.virtualBufferSizeInMs, settings, "uint32_t", "virtualBufferSizeInMs", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.initialVirtualBufferSizeInMs, settings, "uint32_t", "initialVirtualBufferSizeInMs", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkVideoProfileInfoKHR>(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + 1, dump_text_VkVideoProfileInfoKHR);
    dump_text_value<const uint32_t>(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeRateControlModeFlagBitsKHR>(object.preferredRateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "preferredRateControlMode", indents + 1, dump_text_VkVideoEncodeRateControlModeFlagBitsKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredRateControlLayerCount, settings, "uint32_t", "preferredRateControlLayerCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoSessionParametersKHR>(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + 1, dump_text_VkVideoSessionParametersKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hasOverrides, settings, "VkBool32", "hasOverrides", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.diagnosticsConfig, settings, "VkBool32", "diagnosticsConfig", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceDiagnosticsConfigFlagsNV>(object.flags, settings, "VkDeviceDiagnosticsConfigFlagsNV", "flags", indents + 1, dump_text_VkDeviceDiagnosticsConfigFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const size_t>(object.dataSize, settings, "size_t", "dataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "const void*", "pData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCudaModuleNV>(object.module, settings, "VkCudaModuleNV", "module", indents + 1, dump_text_VkCudaModuleNV);  // AET
    dump_text_value<const char*>(object.pName, settings, "const char*", "pName", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCudaFunctionNV>(object.function, settings, "VkCudaFunctionNV", "function", indents + 1, dump_text_VkCudaFunctionNV);  // AET
    dump_text_value<const uint32_t>(object.gridDimX, settings, "uint32_t", "gridDimX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gridDimY, settings, "uint32_t", "gridDimY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimX, settings, "uint32_t", "blockDimX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimY, settings, "uint32_t", "blockDimY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.paramCount, settings, "size_t", "paramCount", indents + 1, dump_text_size_t);  // AET
    dump_text_array<const void*>(object.pParams, object.paramCount, settings, "const void* const *", "const void* const ", "pParams", indents + 1, dump_text_void); // BQB
    dump_text_value<const size_t>(object.extraCount, settings, "size_t", "extraCount", indents + 1, dump_text_size_t);  // AET
    dump_text_array<const void*>(object.pExtras, object.extraCount, settings, "const void* const *", "const void* const ", "pExtras", indents + 1, dump_text_void); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cudaKernelLaunchFeatures, settings, "VkBool32", "cudaKernelLaunchFeatures", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.computeCapabilityMinor, settings, "uint32_t", "computeCapabilityMinor", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.computeCapabilityMajor, settings, "uint32_t", "computeCapabilityMajor", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkPhysicalDeviceTileShadingFeaturesQCOM(const VkPhysicalDeviceTileShadingFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.tileShading, settings, "VkBool32", "tileShading", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingFragmentStage, settings, "VkBool32", "tileShadingFragmentStage", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingColorAttachments, settings, "VkBool32", "tileShadingColorAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingDepthAttachments, settings, "VkBool32", "tileShadingDepthAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingStencilAttachments, settings, "VkBool32", "tileShadingStencilAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingInputAttachments, settings, "VkBool32", "tileShadingInputAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingSampledAttachments, settings, "VkBool32", "tileShadingSampledAttachments", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingPerTileDraw, settings, "VkBool32", "tileShadingPerTileDraw", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingPerTileDispatch, settings, "VkBool32", "tileShadingPerTileDispatch", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingDispatchTile, settings, "VkBool32", "tileShadingDispatchTile", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingApron, settings, "VkBool32", "tileShadingApron", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingAnisotropicApron, settings, "VkBool32", "tileShadingAnisotropicApron", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingAtomicOps, settings, "VkBool32", "tileShadingAtomicOps", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileShadingImageProcessing, settings, "VkBool32", "tileShadingImageProcessing", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTileShadingPropertiesQCOM(const VkPhysicalDeviceTileShadingPropertiesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxApronSize, settings, "uint32_t", "maxApronSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.preferNonCoherent, settings, "VkBool32", "preferNonCoherent", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkExtent2D>(object.tileGranularity, settings, "VkExtent2D", "tileGranularity", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxTileShadingRate, settings, "VkExtent2D", "maxTileShadingRate", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassTileShadingCreateInfoQCOM(const VkRenderPassTileShadingCreateInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkTileShadingRenderPassFlagsQCOM>(object.flags, settings, "VkTileShadingRenderPassFlagsQCOM", "flags", indents + 1, dump_text_VkTileShadingRenderPassFlagsQCOM);  // AET
    dump_text_value<const VkExtent2D>(object.tileApronSize, settings, "VkExtent2D", "tileApronSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.pQueriedLowLatencyData, settings, "void*", "pQueriedLowLatencyData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExportMetalObjectTypeFlagBitsEXT>(object.exportObjectType, settings, "VkExportMetalObjectTypeFlagBitsEXT", "exportObjectType", indents + 1, dump_text_VkExportMetalObjectTypeFlagBitsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const MTLDevice_id>(object.mtlDevice, settings, "MTLDevice_id", "mtlDevice", indents + 1, dump_text_MTLDevice_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueue>(object.queue, settings, "VkQueue", "queue", indents + 1, dump_text_VkQueue);  // AET
    dump_text_value<const MTLCommandQueue_id>(object.mtlCommandQueue, settings, "MTLCommandQueue_id", "mtlCommandQueue", indents + 1, dump_text_MTLCommandQueue_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const MTLBuffer_id>(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + 1, dump_text_MTLBuffer_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const MTLBuffer_id>(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + 1, dump_text_MTLBuffer_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkBufferView>(object.bufferView, settings, "VkBufferView", "bufferView", indents + 1, dump_text_VkBufferView);  // AET
    dump_text_value<const VkImageAspectFlagBits>(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + 1, dump_text_VkImageAspectFlagBits);  // AET
    dump_text_value<const MTLTexture_id>(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + 1, dump_text_MTLTexture_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageAspectFlagBits>(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + 1, dump_text_VkImageAspectFlagBits);  // AET
    dump_text_value<const MTLTexture_id>(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + 1, dump_text_MTLTexture_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    dump_text_value<const IOSurfaceRef>(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + 1, dump_text_IOSurfaceRef);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const IOSurfaceRef>(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + 1, dump_text_IOSurfaceRef);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkEvent>(object.event, settings, "VkEvent", "event", indents + 1, dump_text_VkEvent);  // AET
    dump_text_value<const MTLSharedEvent_id>(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + 1, dump_text_MTLSharedEvent_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const MTLSharedEvent_id>(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + 1, dump_text_MTLSharedEvent_id);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.combinedImageSamplerDescriptorSingleArray, settings, "VkBool32", "combinedImageSamplerDescriptorSingleArray", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bufferlessPushDescriptors, settings, "VkBool32", "bufferlessPushDescriptors", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.allowSamplerImageViewPostSubmitCreation, settings, "VkBool32", "allowSamplerImageViewPostSubmitCreation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.descriptorBufferOffsetAlignment, settings, "VkDeviceSize", "descriptorBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorBufferBindings, settings, "uint32_t", "maxDescriptorBufferBindings", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxResourceDescriptorBufferBindings, settings, "uint32_t", "maxResourceDescriptorBufferBindings", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSamplerDescriptorBufferBindings, settings, "uint32_t", "maxSamplerDescriptorBufferBindings", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxEmbeddedImmutableSamplerBindings, settings, "uint32_t", "maxEmbeddedImmutableSamplerBindings", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxEmbeddedImmutableSamplers, settings, "uint32_t", "maxEmbeddedImmutableSamplers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const size_t>(object.bufferCaptureReplayDescriptorDataSize, settings, "size_t", "bufferCaptureReplayDescriptorDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.imageCaptureReplayDescriptorDataSize, settings, "size_t", "imageCaptureReplayDescriptorDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.imageViewCaptureReplayDescriptorDataSize, settings, "size_t", "imageViewCaptureReplayDescriptorDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.samplerCaptureReplayDescriptorDataSize, settings, "size_t", "samplerCaptureReplayDescriptorDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.accelerationStructureCaptureReplayDescriptorDataSize, settings, "size_t", "accelerationStructureCaptureReplayDescriptorDataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.samplerDescriptorSize, settings, "size_t", "samplerDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.combinedImageSamplerDescriptorSize, settings, "size_t", "combinedImageSamplerDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.sampledImageDescriptorSize, settings, "size_t", "sampledImageDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.storageImageDescriptorSize, settings, "size_t", "storageImageDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.uniformTexelBufferDescriptorSize, settings, "size_t", "uniformTexelBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.robustUniformTexelBufferDescriptorSize, settings, "size_t", "robustUniformTexelBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.storageTexelBufferDescriptorSize, settings, "size_t", "storageTexelBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.robustStorageTexelBufferDescriptorSize, settings, "size_t", "robustStorageTexelBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.uniformBufferDescriptorSize, settings, "size_t", "uniformBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.robustUniformBufferDescriptorSize, settings, "size_t", "robustUniformBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.storageBufferDescriptorSize, settings, "size_t", "storageBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.robustStorageBufferDescriptorSize, settings, "size_t", "robustStorageBufferDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.inputAttachmentDescriptorSize, settings, "size_t", "inputAttachmentDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const size_t>(object.accelerationStructureDescriptorSize, settings, "size_t", "accelerationStructureDescriptorSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const VkDeviceSize>(object.maxSamplerDescriptorBufferRange, settings, "VkDeviceSize", "maxSamplerDescriptorBufferRange", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.maxResourceDescriptorBufferRange, settings, "VkDeviceSize", "maxResourceDescriptorBufferRange", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.samplerDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "samplerDescriptorBufferAddressSpaceSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.resourceDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "resourceDescriptorBufferAddressSpaceSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.descriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "descriptorBufferAddressSpaceSize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const size_t>(object.combinedImageSamplerDensityMapDescriptorSize, settings, "size_t", "combinedImageSamplerDensityMapDescriptorSize", indents + 1, dump_text_size_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.descriptorBuffer, settings, "VkBool32", "descriptorBuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBufferCaptureReplay, settings, "VkBool32", "descriptorBufferCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBufferImageLayoutIgnored, settings, "VkBool32", "descriptorBufferImageLayoutIgnored", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.descriptorBufferPushDescriptors, settings, "VkBool32", "descriptorBufferPushDescriptors", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.range, settings, "VkDeviceSize", "range", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceAddress>(object.address, settings, "VkDeviceAddress", "address", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkBufferUsageFlags>(object.usage, settings, "VkBufferUsageFlags", "usage", indents + 1, dump_text_VkBufferUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    ApiDumpInstance::current().setDescriptorType(object.type);
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorType>(object.type, settings, "VkDescriptorType", "type", indents + 1, dump_text_VkDescriptorType);  // AET
    dump_text_value<const VkDescriptorDataEXT>(object.data, settings, "VkDescriptorDataEXT", "data", indents + 1, dump_text_VkDescriptorDataEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImage>(object.image, settings, "VkImage", "image", indents + 1, dump_text_VkImage);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.imageView, settings, "VkImageView", "imageView", indents + 1, dump_text_VkImageView);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSampler>(object.sampler, settings, "VkSampler", "sampler", indents + 1, dump_text_VkSampler);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const void*>(object.opaqueCaptureDescriptorData, settings, "const void*", "opaqueCaptureDescriptorData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccelerationStructureKHR>(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + 1, dump_text_VkAccelerationStructureKHR);  // AET
    dump_text_value<const VkAccelerationStructureNV>(object.accelerationStructureNV, settings, "VkAccelerationStructureNV", "accelerationStructureNV", indents + 1, dump_text_VkAccelerationStructureNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.graphicsPipelineLibrary, settings, "VkBool32", "graphicsPipelineLibrary", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.graphicsPipelineLibraryFastLinking, settings, "VkBool32", "graphicsPipelineLibraryFastLinking", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.graphicsPipelineLibraryIndependentInterpolationDecoration, settings, "VkBool32", "graphicsPipelineLibraryIndependentInterpolationDecoration", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkGraphicsPipelineLibraryFlagsEXT>(object.flags, settings, "VkGraphicsPipelineLibraryFlagsEXT", "flags", indents + 1, dump_text_VkGraphicsPipelineLibraryFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderEarlyAndLateFragmentTests, settings, "VkBool32", "shaderEarlyAndLateFragmentTests", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.triStripVertexOrderIndependentOfProvokingVertex, settings, "VkBool32", "triStripVertexOrderIndependentOfProvokingVertex", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderSubgroupUniformControlFlow, settings, "VkBool32", "shaderSubgroupUniformControlFlow", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentShadingRateEnums, settings, "VkBool32", "fragmentShadingRateEnums", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.supersampleFragmentShadingRates, settings, "VkBool32", "supersampleFragmentShadingRates", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.noInvocationFragmentShadingRates, settings, "VkBool32", "noInvocationFragmentShadingRates", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkSampleCountFlagBits>(object.maxFragmentShadingRateInvocationCount, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateInvocationCount", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFragmentShadingRateTypeNV>(object.shadingRateType, settings, "VkFragmentShadingRateTypeNV", "shadingRateType", indents + 1, dump_text_VkFragmentShadingRateTypeNV);  // AET
    dump_text_value<const VkFragmentShadingRateNV>(object.shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", indents + 1, dump_text_VkFragmentShadingRateNV);  // AET
    dump_text_array<const VkFragmentShadingRateCombinerOpKHR>(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "VkFragmentShadingRateCombinerOpKHR", "combinerOps", indents + 1, dump_text_VkFragmentShadingRateCombinerOpKHR); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxInstances, settings, "uint32_t", "maxInstances", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkAccelerationStructureMotionInfoFlagsNV>(object.flags, settings, "VkAccelerationStructureMotionInfoFlagsNV", "flags", indents + 1, dump_text_VkAccelerationStructureMotionInfoFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureMatrixMotionInstanceNV(const VkAccelerationStructureMatrixMotionInstanceNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkTransformMatrixKHR>(object.transformT0, settings, "VkTransformMatrixKHR", "transformT0", indents + 1, dump_text_VkTransformMatrixKHR);  // AET
    dump_text_value<const VkTransformMatrixKHR>(object.transformT1, settings, "VkTransformMatrixKHR", "transformT1", indents + 1, dump_text_VkTransformMatrixKHR);  // AET
    dump_text_value<const uint32_t>(object.instanceCustomIndex, settings, "uint32_t instanceCustomIndex:24", "instanceCustomIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.mask, settings, "uint32_t mask:8", "mask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t instanceShaderBindingTableRecordOffset:24", "instanceShaderBindingTableRecordOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkGeometryInstanceFlagsKHR>(object.flags, settings, "VkGeometryInstanceFlagsKHR flags:8", "flags", indents + 1, dump_text_VkGeometryInstanceFlagsKHR);  // AET
    dump_text_value<const uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkSRTDataNV(const VkSRTDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.sx, settings, "float", "sx", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.a, settings, "float", "a", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.b, settings, "float", "b", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.pvx, settings, "float", "pvx", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.sy, settings, "float", "sy", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.c, settings, "float", "c", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.pvy, settings, "float", "pvy", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.sz, settings, "float", "sz", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.pvz, settings, "float", "pvz", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.qx, settings, "float", "qx", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.qy, settings, "float", "qy", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.qz, settings, "float", "qz", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.qw, settings, "float", "qw", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.tx, settings, "float", "tx", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.ty, settings, "float", "ty", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.tz, settings, "float", "tz", indents + 1, dump_text_float);  // AET
}
void dump_text_VkAccelerationStructureSRTMotionInstanceNV(const VkAccelerationStructureSRTMotionInstanceNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkSRTDataNV>(object.transformT0, settings, "VkSRTDataNV", "transformT0", indents + 1, dump_text_VkSRTDataNV);  // AET
    dump_text_value<const VkSRTDataNV>(object.transformT1, settings, "VkSRTDataNV", "transformT1", indents + 1, dump_text_VkSRTDataNV);  // AET
    dump_text_value<const uint32_t>(object.instanceCustomIndex, settings, "uint32_t instanceCustomIndex:24", "instanceCustomIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.mask, settings, "uint32_t mask:8", "mask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t instanceShaderBindingTableRecordOffset:24", "instanceShaderBindingTableRecordOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkGeometryInstanceFlagsKHR>(object.flags, settings, "VkGeometryInstanceFlagsKHR flags:8", "flags", indents + 1, dump_text_VkGeometryInstanceFlagsKHR);  // AET
    dump_text_value<const uint64_t>(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkAccelerationStructureMotionInstanceNV(const VkAccelerationStructureMotionInstanceNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkAccelerationStructureMotionInstanceTypeNV>(object.type, settings, "VkAccelerationStructureMotionInstanceTypeNV", "type", indents + 1, dump_text_VkAccelerationStructureMotionInstanceTypeNV);  // AET
    dump_text_value<const VkAccelerationStructureMotionInstanceFlagsNV>(object.flags, settings, "VkAccelerationStructureMotionInstanceFlagsNV", "flags", indents + 1, dump_text_VkAccelerationStructureMotionInstanceFlagsNV);  // AET
    dump_text_value<const VkAccelerationStructureMotionInstanceDataNV>(object.data, settings, "VkAccelerationStructureMotionInstanceDataNV", "data", indents + 1, dump_text_VkAccelerationStructureMotionInstanceDataNV);  // AET
}
void dump_text_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingMotionBlur, settings, "VkBool32", "rayTracingMotionBlur", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTracingMotionBlurPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingMotionBlurPipelineTraceRaysIndirect", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.taskShader, settings, "VkBool32", "taskShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.meshShader, settings, "VkBool32", "meshShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewMeshShader, settings, "VkBool32", "multiviewMeshShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.primitiveFragmentShadingRateMeshShader, settings, "VkBool32", "primitiveFragmentShadingRateMeshShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.meshShaderQueries, settings, "VkBool32", "meshShaderQueries", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxTaskWorkGroupTotalCount, settings, "uint32_t", "maxTaskWorkGroupTotalCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxTaskWorkGroupCount, 3, settings, "uint32_t[3]", "uint32_t", "maxTaskWorkGroupCount", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxTaskWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxTaskPayloadSize, settings, "uint32_t", "maxTaskPayloadSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTaskSharedMemorySize, settings, "uint32_t", "maxTaskSharedMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTaskPayloadAndSharedMemorySize, settings, "uint32_t", "maxTaskPayloadAndSharedMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshWorkGroupTotalCount, settings, "uint32_t", "maxMeshWorkGroupTotalCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxMeshWorkGroupCount, 3, settings, "uint32_t[3]", "uint32_t", "maxMeshWorkGroupCount", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxMeshWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxMeshSharedMemorySize, settings, "uint32_t", "maxMeshSharedMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshPayloadAndSharedMemorySize, settings, "uint32_t", "maxMeshPayloadAndSharedMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputMemorySize, settings, "uint32_t", "maxMeshOutputMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshPayloadAndOutputMemorySize, settings, "uint32_t", "maxMeshPayloadAndOutputMemorySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputComponents, settings, "uint32_t", "maxMeshOutputComponents", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshOutputLayers, settings, "uint32_t", "maxMeshOutputLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPreferredTaskWorkGroupInvocations, settings, "uint32_t", "maxPreferredTaskWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPreferredMeshWorkGroupInvocations, settings, "uint32_t", "maxPreferredMeshWorkGroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.prefersLocalInvocationVertexOutput, settings, "VkBool32", "prefersLocalInvocationVertexOutput", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.prefersLocalInvocationPrimitiveOutput, settings, "VkBool32", "prefersLocalInvocationPrimitiveOutput", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.prefersCompactVertexOutput, settings, "VkBool32", "prefersCompactVertexOutput", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.prefersCompactPrimitiveOutput, settings, "VkBool32", "prefersCompactPrimitiveOutput", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.groupCountX, settings, "uint32_t", "groupCountX", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.groupCountY, settings, "uint32_t", "groupCountY", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.groupCountZ, settings, "uint32_t", "groupCountZ", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.ycbcr2plane444Formats, settings, "VkBool32", "ycbcr2plane444Formats", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentDensityMapDeferred, settings, "VkBool32", "fragmentDensityMapDeferred", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.subsampledLoads, settings, "VkBool32", "subsampledLoads", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.subsampledCoarseReconstructionEarlyAccess, settings, "VkBool32", "subsampledCoarseReconstructionEarlyAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxSubsampledArrayLayers, settings, "uint32_t", "maxSubsampledArrayLayers", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetSubsampledSamplers, settings, "uint32_t", "maxDescriptorSetSubsampledSamplers", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSurfaceTransformFlagBitsKHR>(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + 1, dump_text_VkSurfaceTransformFlagBitsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.workgroupMemoryExplicitLayout, settings, "VkBool32", "workgroupMemoryExplicitLayout", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.workgroupMemoryExplicitLayoutScalarBlockLayout, settings, "VkBool32", "workgroupMemoryExplicitLayoutScalarBlockLayout", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.workgroupMemoryExplicitLayout8BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout8BitAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.workgroupMemoryExplicitLayout16BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout16BitAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imageCompressionControl, settings, "VkBool32", "imageCompressionControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageCompressionControlEXT(const VkImageCompressionControlEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageCompressionFlagsEXT>(object.flags, settings, "VkImageCompressionFlagsEXT", "flags", indents + 1, dump_text_VkImageCompressionFlagsEXT);  // AET
    dump_text_value<const uint32_t>(object.compressionControlPlaneCount, settings, "uint32_t", "compressionControlPlaneCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageCompressionFixedRateFlagsEXT>(object.pFixedRateFlags, object.compressionControlPlaneCount, settings, "VkImageCompressionFixedRateFlagsEXT*", "VkImageCompressionFixedRateFlagsEXT", "pFixedRateFlags", indents + 1, dump_text_VkImageCompressionFixedRateFlagsEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkImageCompressionFlagsEXT>(object.imageCompressionFlags, settings, "VkImageCompressionFlagsEXT", "imageCompressionFlags", indents + 1, dump_text_VkImageCompressionFlagsEXT);  // AET
    dump_text_value<const VkImageCompressionFixedRateFlagsEXT>(object.imageCompressionFixedRateFlags, settings, "VkImageCompressionFixedRateFlagsEXT", "imageCompressionFixedRateFlags", indents + 1, dump_text_VkImageCompressionFixedRateFlagsEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.attachmentFeedbackLoopLayout, settings, "VkBool32", "attachmentFeedbackLoopLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.formatA4R4G4B4, settings, "VkBool32", "formatA4R4G4B4", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.formatA4B4G4R4, settings, "VkBool32", "formatA4B4G4R4", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceFault, settings, "VkBool32", "deviceFault", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.deviceFaultVendorBinary, settings, "VkBool32", "deviceFaultVendorBinary", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.addressInfoCount, settings, "uint32_t", "addressInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vendorInfoCount, settings, "uint32_t", "vendorInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.vendorBinarySize, settings, "VkDeviceSize", "vendorBinarySize", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceFaultAddressTypeEXT>(object.addressType, settings, "VkDeviceFaultAddressTypeEXT", "addressType", indents + 1, dump_text_VkDeviceFaultAddressTypeEXT);  // AET
    dump_text_value<const VkDeviceAddress>(object.reportedAddress, settings, "VkDeviceAddress", "reportedAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.addressPrecision, settings, "VkDeviceSize", "addressPrecision", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint64_t>(object.vendorFaultCode, settings, "uint64_t", "vendorFaultCode", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.vendorFaultData, settings, "uint64_t", "vendorFaultData", indents + 1, dump_text_uint64_t);  // AET
}
void dump_text_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_pointer<const VkDeviceFaultAddressInfoEXT>(object.pAddressInfos, settings, "VkDeviceFaultAddressInfoEXT*", "pAddressInfos", indents + 1, dump_text_VkDeviceFaultAddressInfoEXT);
    dump_text_pointer<const VkDeviceFaultVendorInfoEXT>(object.pVendorInfos, settings, "VkDeviceFaultVendorInfoEXT*", "pVendorInfos", indents + 1, dump_text_VkDeviceFaultVendorInfoEXT);
    dump_text_value<const void*>(object.pVendorBinaryData, settings, "void*", "pVendorBinaryData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(const VkDeviceFaultVendorBinaryHeaderVersionOneEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.headerSize, settings, "uint32_t", "headerSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceFaultVendorBinaryHeaderVersionEXT>(object.headerVersion, settings, "VkDeviceFaultVendorBinaryHeaderVersionEXT", "headerVersion", indents + 1, dump_text_VkDeviceFaultVendorBinaryHeaderVersionEXT);  // AET
    dump_text_value<const uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.driverVersion, settings, "uint32_t", "driverVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint8_t>(object.pipelineCacheUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "pipelineCacheUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const uint32_t>(object.applicationNameOffset, settings, "uint32_t", "applicationNameOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.engineNameOffset, settings, "uint32_t", "engineNameOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.engineVersion, settings, "uint32_t", "engineVersion", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.apiVersion, settings, "uint32_t", "apiVersion", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rasterizationOrderColorAttachmentAccess, settings, "VkBool32", "rasterizationOrderColorAttachmentAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rasterizationOrderDepthAttachmentAccess, settings, "VkBool32", "rasterizationOrderDepthAttachmentAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rasterizationOrderStencilAttachmentAccess, settings, "VkBool32", "rasterizationOrderStencilAttachmentAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.formatRgba10x6WithoutYCbCrSampler, settings, "VkBool32", "formatRgba10x6WithoutYCbCrSampler", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDirectFBSurfaceCreateFlagsEXT>(object.flags, settings, "VkDirectFBSurfaceCreateFlagsEXT", "flags", indents + 1, dump_text_VkDirectFBSurfaceCreateFlagsEXT);  // AET
    dump_text_pointer<const IDirectFB>(object.dfb, settings, "IDirectFB*", "dfb", indents + 1, dump_text_IDirectFB);
    dump_text_pointer<const IDirectFBSurface>(object.surface, settings, "IDirectFBSurface*", "surface", indents + 1, dump_text_IDirectFBSurface);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
void dump_text_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRayTracingShaderGroupTypeKHR>(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + 1, dump_text_VkRayTracingShaderGroupTypeKHR);  // AET
    dump_text_value<const uint32_t>(object.generalShader, settings, "uint32_t", "generalShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pShaderGroupCaptureReplayHandle, settings, "const void*", "pShaderGroupCaptureReplayHandle", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maxPipelineRayPayloadSize, settings, "uint32_t", "maxPipelineRayPayloadSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxPipelineRayHitAttributeSize, settings, "uint32_t", "maxPipelineRayHitAttributeSize", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineCreateFlags>(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + 1, dump_text_VkPipelineCreateFlags);  // AET
    dump_text_value<const uint32_t>(object.stageCount, settings, "uint32_t", "stageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineShaderStageCreateInfo>(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "const VkPipelineShaderStageCreateInfo", "pStages", indents + 1, dump_text_VkPipelineShaderStageCreateInfo); // BQB
    dump_text_value<const uint32_t>(object.groupCount, settings, "uint32_t", "groupCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRayTracingShaderGroupCreateInfoKHR>(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoKHR*", "const VkRayTracingShaderGroupCreateInfoKHR", "pGroups", indents + 1, dump_text_VkRayTracingShaderGroupCreateInfoKHR); // BQB
    dump_text_value<const uint32_t>(object.maxPipelineRayRecursionDepth, settings, "uint32_t", "maxPipelineRayRecursionDepth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkPipelineLibraryCreateInfoKHR>(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + 1, dump_text_VkPipelineLibraryCreateInfoKHR);
    dump_text_pointer<const VkRayTracingPipelineInterfaceCreateInfoKHR>(object.pLibraryInterface, settings, "const VkRayTracingPipelineInterfaceCreateInfoKHR*", "pLibraryInterface", indents + 1, dump_text_VkRayTracingPipelineInterfaceCreateInfoKHR);
    dump_text_pointer<const VkPipelineDynamicStateCreateInfo>(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + 1, dump_text_VkPipelineDynamicStateCreateInfo);
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const VkPipeline>(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const int32_t>(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingPipeline, settings, "VkBool32", "rayTracingPipeline", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTracingPipelineShaderGroupHandleCaptureReplay, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTracingPipelineShaderGroupHandleCaptureReplayMixed, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplayMixed", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTracingPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTraversalPrimitiveCulling, settings, "VkBool32", "rayTraversalPrimitiveCulling", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxRayRecursionDepth, settings, "uint32_t", "maxRayRecursionDepth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderGroupHandleCaptureReplaySize, settings, "uint32_t", "shaderGroupHandleCaptureReplaySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxRayDispatchInvocationCount, settings, "uint32_t", "maxRayDispatchInvocationCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderGroupHandleAlignment, settings, "uint32_t", "shaderGroupHandleAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxRayHitAttributeSize, settings, "uint32_t", "maxRayHitAttributeSize", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkStridedDeviceAddressRegionKHR(const VkStridedDeviceAddressRegionKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.stride, settings, "VkDeviceSize", "stride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkTraceRaysIndirectCommandKHR(const VkTraceRaysIndirectCommandKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.depth, settings, "uint32_t", "depth", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayQuery, settings, "VkBool32", "rayQuery", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.mutableDescriptorType, settings, "VkBool32", "mutableDescriptorType", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.descriptorTypeCount, settings, "uint32_t", "descriptorTypeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorType>(object.pDescriptorTypes, object.descriptorTypeCount, settings, "const VkDescriptorType*", "const VkDescriptorType", "pDescriptorTypes", indents + 1, dump_text_VkDescriptorType); // BQB
}
void dump_text_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.mutableDescriptorTypeListCount, settings, "uint32_t", "mutableDescriptorTypeListCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMutableDescriptorTypeListEXT>(object.pMutableDescriptorTypeLists, object.mutableDescriptorTypeListCount, settings, "const VkMutableDescriptorTypeListEXT*", "const VkMutableDescriptorTypeListEXT", "pMutableDescriptorTypeLists", indents + 1, dump_text_VkMutableDescriptorTypeListEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.vertexInputDynamicState, settings, "VkBool32", "vertexInputDynamicState", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVertexInputRate>(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + 1, dump_text_VkVertexInputRate);  // AET
    dump_text_value<const uint32_t>(object.divisor, settings, "uint32_t", "divisor", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.location, settings, "uint32_t", "location", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hasPrimary, settings, "VkBool32", "hasPrimary", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.hasRender, settings, "VkBool32", "hasRender", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const int64_t>(object.primaryMajor, settings, "int64_t", "primaryMajor", indents + 1, dump_text_int64_t);  // AET
    dump_text_value<const int64_t>(object.primaryMinor, settings, "int64_t", "primaryMinor", indents + 1, dump_text_int64_t);  // AET
    dump_text_value<const int64_t>(object.renderMajor, settings, "int64_t", "renderMajor", indents + 1, dump_text_int64_t);  // AET
    dump_text_value<const int64_t>(object.renderMinor, settings, "int64_t", "renderMinor", indents + 1, dump_text_int64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.reportAddressBinding, settings, "VkBool32", "reportAddressBinding", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceAddressBindingFlagsEXT>(object.flags, settings, "VkDeviceAddressBindingFlagsEXT", "flags", indents + 1, dump_text_VkDeviceAddressBindingFlagsEXT);  // AET
    dump_text_value<const VkDeviceAddress>(object.baseAddress, settings, "VkDeviceAddress", "baseAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddressBindingTypeEXT>(object.bindingType, settings, "VkDeviceAddressBindingTypeEXT", "bindingType", indents + 1, dump_text_VkDeviceAddressBindingTypeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.depthClipControl, settings, "VkBool32", "depthClipControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.negativeOneToOne, settings, "VkBool32", "negativeOneToOne", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.primitiveTopologyListRestart, settings, "VkBool32", "primitiveTopologyListRestart", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.primitiveTopologyPatchListRestart, settings, "VkBool32", "primitiveTopologyPatchListRestart", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentModeFifoLatestReady, settings, "VkBool32", "presentModeFifoLatestReady", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    dump_text_value<const zx_handle_t>(object.handle, settings, "zx_handle_t", "handle", indents + 1, dump_text_zx_handle_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkSemaphoreImportFlags>(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + 1, dump_text_VkSemaphoreImportFlags);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    dump_text_value<const zx_handle_t>(object.zirconHandle, settings, "zx_handle_t", "zirconHandle", indents + 1, dump_text_zx_handle_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.semaphore, settings, "VkSemaphore", "semaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const VkExternalSemaphoreHandleTypeFlagBits>(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalSemaphoreHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const zx_handle_t>(object.collectionToken, settings, "zx_handle_t", "collectionToken", indents + 1, dump_text_zx_handle_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCollectionFUCHSIA>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + 1, dump_text_VkBufferCollectionFUCHSIA);  // AET
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCollectionFUCHSIA>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + 1, dump_text_VkBufferCollectionFUCHSIA);  // AET
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.minBufferCount, settings, "uint32_t", "minBufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBufferCount, settings, "uint32_t", "maxBufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minBufferCountForCamping, settings, "uint32_t", "minBufferCountForCamping", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minBufferCountForDedicatedSlack, settings, "uint32_t", "minBufferCountForDedicatedSlack", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minBufferCountForSharedSlack, settings, "uint32_t", "minBufferCountForSharedSlack", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCreateInfo>(object.createInfo, settings, "VkBufferCreateInfo", "createInfo", indents + 1, dump_text_VkBufferCreateInfo);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkBufferCollectionConstraintsInfoFUCHSIA>(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + 1, dump_text_VkBufferCollectionConstraintsInfoFUCHSIA);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBufferCollectionFUCHSIA>(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + 1, dump_text_VkBufferCollectionFUCHSIA);  // AET
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.colorSpace, settings, "uint32_t", "colorSpace", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bufferCount, settings, "uint32_t", "bufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.createInfoIndex, settings, "uint32_t", "createInfoIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint64_t>(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkSysmemColorSpaceFUCHSIA>(object.sysmemColorSpaceIndex, settings, "VkSysmemColorSpaceFUCHSIA", "sysmemColorSpaceIndex", indents + 1, dump_text_VkSysmemColorSpaceFUCHSIA);  // AET
    dump_text_value<const VkComponentMapping>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkSamplerYcbcrModelConversion>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + 1, dump_text_VkSamplerYcbcrModelConversion);  // AET
    dump_text_value<const VkSamplerYcbcrRange>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + 1, dump_text_VkSamplerYcbcrRange);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageCreateInfo>(object.imageCreateInfo, settings, "VkImageCreateInfo", "imageCreateInfo", indents + 1, dump_text_VkImageCreateInfo);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkImageFormatConstraintsFlagsFUCHSIA>(object.flags, settings, "VkImageFormatConstraintsFlagsFUCHSIA", "flags", indents + 1, dump_text_VkImageFormatConstraintsFlagsFUCHSIA);  // AET
    dump_text_value<const uint64_t>(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.colorSpaceCount, settings, "uint32_t", "colorSpaceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSysmemColorSpaceFUCHSIA>(object.pColorSpaces, object.colorSpaceCount, settings, "const VkSysmemColorSpaceFUCHSIA*", "const VkSysmemColorSpaceFUCHSIA", "pColorSpaces", indents + 1, dump_text_VkSysmemColorSpaceFUCHSIA); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.formatConstraintsCount, settings, "uint32_t", "formatConstraintsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImageFormatConstraintsInfoFUCHSIA>(object.pFormatConstraints, object.formatConstraintsCount, settings, "const VkImageFormatConstraintsInfoFUCHSIA*", "const VkImageFormatConstraintsInfoFUCHSIA", "pFormatConstraints", indents + 1, dump_text_VkImageFormatConstraintsInfoFUCHSIA); // BQB
    dump_text_value<const VkBufferCollectionConstraintsInfoFUCHSIA>(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + 1, dump_text_VkBufferCollectionConstraintsInfoFUCHSIA);  // AET
    dump_text_value<const VkImageConstraintsInfoFlagsFUCHSIA>(object.flags, settings, "VkImageConstraintsInfoFlagsFUCHSIA", "flags", indents + 1, dump_text_VkImageConstraintsInfoFlagsFUCHSIA);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_FUCHSIA
void dump_text_VkSubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkRenderPass>(object.renderPass, settings, "VkRenderPass", "renderPass", indents + 1, dump_text_VkRenderPass);  // AET
    dump_text_value<const uint32_t>(object.subpass, settings, "uint32_t", "subpass", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.subpassShading, settings, "VkBool32", "subpassShading", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxSubpassShadingWorkgroupSizeAspectRatio, settings, "uint32_t", "maxSubpassShadingWorkgroupSizeAspectRatio", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.invocationMask, settings, "VkBool32", "invocationMask", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.externalMemoryRDMA, settings, "VkBool32", "externalMemoryRDMA", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint8_t>(object.pipelineIdentifier, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "pipelineIdentifier", indents + 1, dump_text_uint8_t); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelinePropertiesIdentifier, settings, "VkBool32", "pipelinePropertiesIdentifier", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.frameBoundary, settings, "VkBool32", "frameBoundary", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkFrameBoundaryEXT(const VkFrameBoundaryEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFrameBoundaryFlagsEXT>(object.flags, settings, "VkFrameBoundaryFlagsEXT", "flags", indents + 1, dump_text_VkFrameBoundaryFlagsEXT);  // AET
    dump_text_value<const uint64_t>(object.frameID, settings, "uint64_t", "frameID", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.imageCount, settings, "uint32_t", "imageCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkImage>(object.pImages, object.imageCount, settings, "const VkImage*", "const VkImage", "pImages", indents + 1, dump_text_VkImage); // BQB
    dump_text_value<const uint32_t>(object.bufferCount, settings, "uint32_t", "bufferCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBuffer>(object.pBuffers, object.bufferCount, settings, "const VkBuffer*", "const VkBuffer", "pBuffers", indents + 1, dump_text_VkBuffer); // BQB
    dump_text_value<const uint64_t>(object.tagName, settings, "uint64_t", "tagName", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const size_t>(object.tagSize, settings, "size_t", "tagSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pTag, settings, "const void*", "pTag", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.multisampledRenderToSingleSampled, settings, "VkBool32", "multisampledRenderToSingleSampled", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.optimal, settings, "VkBool32", "optimal", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.multisampledRenderToSingleSampledEnable, settings, "VkBool32", "multisampledRenderToSingleSampledEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkSampleCountFlagBits>(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + 1, dump_text_VkSampleCountFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.extendedDynamicState2, settings, "VkBool32", "extendedDynamicState2", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState2LogicOp, settings, "VkBool32", "extendedDynamicState2LogicOp", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState2PatchControlPoints, settings, "VkBool32", "extendedDynamicState2PatchControlPoints", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkScreenSurfaceCreateFlagsQNX>(object.flags, settings, "VkScreenSurfaceCreateFlagsQNX", "flags", indents + 1, dump_text_VkScreenSurfaceCreateFlagsQNX);  // AET
    dump_text_value<const _screen_context*>(object.context, settings, "struct _screen_context*", "context", indents + 1, dump_text__screen_context);  // AET
    dump_text_value<const _screen_window*>(object.window, settings, "struct _screen_window*", "window", indents + 1, dump_text__screen_window);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
void dump_text_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.colorWriteEnable, settings, "VkBool32", "colorWriteEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkBool32>(object.pColorWriteEnables, object.attachmentCount, settings, "const VkBool32*", "const VkBool32", "pColorWriteEnables", indents + 1, dump_text_VkBool32); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.primitivesGeneratedQuery, settings, "VkBool32", "primitivesGeneratedQuery", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.primitivesGeneratedQueryWithRasterizerDiscard, settings, "VkBool32", "primitivesGeneratedQueryWithRasterizerDiscard", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.primitivesGeneratedQueryWithNonZeroStreams, settings, "VkBool32", "primitivesGeneratedQueryWithNonZeroStreams", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingMaintenance1, settings, "VkBool32", "rayTracingMaintenance1", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.rayTracingPipelineTraceRaysIndirect2, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.raygenShaderRecordAddress, settings, "VkDeviceAddress", "raygenShaderRecordAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.raygenShaderRecordSize, settings, "VkDeviceSize", "raygenShaderRecordSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddress>(object.missShaderBindingTableAddress, settings, "VkDeviceAddress", "missShaderBindingTableAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.missShaderBindingTableSize, settings, "VkDeviceSize", "missShaderBindingTableSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.missShaderBindingTableStride, settings, "VkDeviceSize", "missShaderBindingTableStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddress>(object.hitShaderBindingTableAddress, settings, "VkDeviceAddress", "hitShaderBindingTableAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.hitShaderBindingTableSize, settings, "VkDeviceSize", "hitShaderBindingTableSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.hitShaderBindingTableStride, settings, "VkDeviceSize", "hitShaderBindingTableStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddress>(object.callableShaderBindingTableAddress, settings, "VkDeviceAddress", "callableShaderBindingTableAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.callableShaderBindingTableSize, settings, "VkDeviceSize", "callableShaderBindingTableSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.callableShaderBindingTableStride, settings, "VkDeviceSize", "callableShaderBindingTableStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.depth, settings, "uint32_t", "depth", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.minLod, settings, "VkBool32", "minLod", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const float>(object.minLod, settings, "float", "minLod", indents + 1, dump_text_float);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.multiDraw, settings, "VkBool32", "multiDraw", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxMultiDrawCount, settings, "uint32_t", "maxMultiDrawCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMultiDrawInfoEXT(const VkMultiDrawInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.firstVertex, settings, "uint32_t", "firstVertex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vertexCount, settings, "uint32_t", "vertexCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.firstIndex, settings, "uint32_t", "firstIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.indexCount, settings, "uint32_t", "indexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const int32_t>(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + 1, dump_text_int32_t);  // AET
}
void dump_text_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.image2DViewOf3D, settings, "VkBool32", "image2DViewOf3D", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.sampler2DViewOf3D, settings, "VkBool32", "sampler2DViewOf3D", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderTileImageColorReadAccess, settings, "VkBool32", "shaderTileImageColorReadAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTileImageDepthReadAccess, settings, "VkBool32", "shaderTileImageDepthReadAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTileImageStencilReadAccess, settings, "VkBool32", "shaderTileImageStencilReadAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderTileImageCoherentReadAccelerated, settings, "VkBool32", "shaderTileImageCoherentReadAccelerated", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTileImageReadSampleFromPixelRateInvocation, settings, "VkBool32", "shaderTileImageReadSampleFromPixelRateInvocation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.shaderTileImageReadFromHelperInvocation, settings, "VkBool32", "shaderTileImageReadFromHelperInvocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMicromapUsageEXT(const VkMicromapUsageEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.count, settings, "uint32_t", "count", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.subdivisionLevel, settings, "uint32_t", "subdivisionLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.format, settings, "uint32_t", "format", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMicromapTypeEXT>(object.type, settings, "VkMicromapTypeEXT", "type", indents + 1, dump_text_VkMicromapTypeEXT);  // AET
    dump_text_value<const VkBuildMicromapFlagsEXT>(object.flags, settings, "VkBuildMicromapFlagsEXT", "flags", indents + 1, dump_text_VkBuildMicromapFlagsEXT);  // AET
    dump_text_value<const VkBuildMicromapModeEXT>(object.mode, settings, "VkBuildMicromapModeEXT", "mode", indents + 1, dump_text_VkBuildMicromapModeEXT);  // AET
    dump_text_value<const VkMicromapEXT>(object.dstMicromap, settings, "VkMicromapEXT", "dstMicromap", indents + 1, dump_text_VkMicromapEXT);  // AET
    dump_text_value<const uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMicromapUsageEXT>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "const VkMicromapUsageEXT", "pUsageCounts", indents + 1, dump_text_VkMicromapUsageEXT); // BQB
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceOrHostAddressKHR>(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + 1, dump_text_VkDeviceOrHostAddressKHR);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.triangleArray, settings, "VkDeviceOrHostAddressConstKHR", "triangleArray", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.triangleArrayStride, settings, "VkDeviceSize", "triangleArrayStride", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMicromapCreateFlagsEXT>(object.createFlags, settings, "VkMicromapCreateFlagsEXT", "createFlags", indents + 1, dump_text_VkMicromapCreateFlagsEXT);  // AET
    dump_text_value<const VkBuffer>(object.buffer, settings, "VkBuffer", "buffer", indents + 1, dump_text_VkBuffer);  // AET
    dump_text_value<const VkDeviceSize>(object.offset, settings, "VkDeviceSize", "offset", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkMicromapTypeEXT>(object.type, settings, "VkMicromapTypeEXT", "type", indents + 1, dump_text_VkMicromapTypeEXT);  // AET
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.micromap, settings, "VkBool32", "micromap", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.micromapCaptureReplay, settings, "VkBool32", "micromapCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.micromapHostCommands, settings, "VkBool32", "micromapHostCommands", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxOpacity2StateSubdivisionLevel, settings, "uint32_t", "maxOpacity2StateSubdivisionLevel", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxOpacity4StateSubdivisionLevel, settings, "uint32_t", "maxOpacity4StateSubdivisionLevel", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_array<const uint8_t>(object.pVersionData, 2*VK_UUID_SIZE, settings, "const uint8_t*", "const uint8_t", "pVersionData", indents + 1, dump_text_uint8_t); // BQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMicromapEXT>(object.src, settings, "VkMicromapEXT", "src", indents + 1, dump_text_VkMicromapEXT);  // AET
    dump_text_value<const VkDeviceOrHostAddressKHR>(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + 1, dump_text_VkDeviceOrHostAddressKHR);  // AET
    dump_text_value<const VkCopyMicromapModeEXT>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + 1, dump_text_VkCopyMicromapModeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkMicromapEXT>(object.dst, settings, "VkMicromapEXT", "dst", indents + 1, dump_text_VkMicromapEXT);  // AET
    dump_text_value<const VkCopyMicromapModeEXT>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + 1, dump_text_VkCopyMicromapModeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkMicromapEXT>(object.src, settings, "VkMicromapEXT", "src", indents + 1, dump_text_VkMicromapEXT);  // AET
    dump_text_value<const VkMicromapEXT>(object.dst, settings, "VkMicromapEXT", "dst", indents + 1, dump_text_VkMicromapEXT);  // AET
    dump_text_value<const VkCopyMicromapModeEXT>(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + 1, dump_text_VkCopyMicromapModeEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.micromapSize, settings, "VkDeviceSize", "micromapSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkBool32>(object.discardable, settings, "VkBool32", "discardable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMicromapUsageEXT>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "const VkMicromapUsageEXT", "pUsageCounts", indents + 1, dump_text_VkMicromapUsageEXT); // BQB
    dump_text_value<const VkMicromapEXT>(object.micromap, settings, "VkMicromapEXT", "micromap", indents + 1, dump_text_VkMicromapEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMicromapTriangleEXT(const VkMicromapTriangleEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.dataOffset, settings, "uint32_t", "dataOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint16_t>(object.subdivisionLevel, settings, "uint16_t", "subdivisionLevel", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.format, settings, "uint16_t", "format", indents + 1, dump_text_uint16_t);  // AET
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.displacementMicromap, settings, "VkBool32", "displacementMicromap", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxDisplacementMicromapSubdivisionLevel, settings, "uint32_t", "maxDisplacementMicromapSubdivisionLevel", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkAccelerationStructureTrianglesDisplacementMicromapNV(const VkAccelerationStructureTrianglesDisplacementMicromapNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.displacementBiasAndScaleFormat, settings, "VkFormat", "displacementBiasAndScaleFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkFormat>(object.displacementVectorFormat, settings, "VkFormat", "displacementVectorFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.displacementBiasAndScaleBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementBiasAndScaleBuffer", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.displacementBiasAndScaleStride, settings, "VkDeviceSize", "displacementBiasAndScaleStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.displacementVectorBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementVectorBuffer", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.displacementVectorStride, settings, "VkDeviceSize", "displacementVectorStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.displacedMicromapPrimitiveFlags, settings, "VkDeviceOrHostAddressConstKHR", "displacedMicromapPrimitiveFlags", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.displacedMicromapPrimitiveFlagsStride, settings, "VkDeviceSize", "displacedMicromapPrimitiveFlagsStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkMicromapUsageEXT>(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "const VkMicromapUsageEXT", "pUsageCounts", indents + 1, dump_text_VkMicromapUsageEXT); // BQB
    dump_text_value<const VkMicromapEXT>(object.micromap, settings, "VkMicromapEXT", "micromap", indents + 1, dump_text_VkMicromapEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*pNext");
    dump_text_value<const VkBool32>(object.clustercullingShader, settings, "VkBool32", "clustercullingShader", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.multiviewClusterCullingShader, settings, "VkBool32", "multiviewClusterCullingShader", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint32_t>(object.maxWorkGroupCount, 3, settings, "uint32_t[3]", "uint32_t", "maxWorkGroupCount", indents + 1, dump_text_uint32_t); // AQA
    dump_text_array<const uint32_t>(object.maxWorkGroupSize, 3, settings, "uint32_t[3]", "uint32_t", "maxWorkGroupSize", indents + 1, dump_text_uint32_t); // AQA
    dump_text_value<const uint32_t>(object.maxOutputClusterCount, settings, "uint32_t", "maxOutputClusterCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceSize>(object.indirectBufferOffsetAlignment, settings, "VkDeviceSize", "indirectBufferOffsetAlignment", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*pNext");
    dump_text_value<const VkBool32>(object.clusterShadingRate, settings, "VkBool32", "clusterShadingRate", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.borderColorSwizzle, settings, "VkBool32", "borderColorSwizzle", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.borderColorSwizzleFromImage, settings, "VkBool32", "borderColorSwizzleFromImage", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkComponentMapping>(object.components, settings, "VkComponentMapping", "components", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkBool32>(object.srgb, settings, "VkBool32", "srgb", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pageableDeviceLocalMemory, settings, "VkBool32", "pageableDeviceLocalMemory", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.pixelRate, settings, "uint32_t", "pixelRate", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.texelRate, settings, "uint32_t", "texelRate", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.fmaRate, settings, "uint32_t", "fmaRate", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.schedulingControls, settings, "VkBool32", "schedulingControls", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPhysicalDeviceSchedulingControlsFlagsARM>(object.schedulingControlsFlags, settings, "VkPhysicalDeviceSchedulingControlsFlagsARM", "schedulingControlsFlags", indents + 1, dump_text_VkPhysicalDeviceSchedulingControlsFlagsARM);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imageSlicedViewOf3D, settings, "VkBool32", "imageSlicedViewOf3D", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.sliceOffset, settings, "uint32_t", "sliceOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.sliceCount, settings, "uint32_t", "sliceCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.descriptorSetHostMapping, settings, "VkBool32", "descriptorSetHostMapping", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDescriptorSetLayout>(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + 1, dump_text_VkDescriptorSetLayout);  // AET
    dump_text_value<const uint32_t>(object.binding, settings, "uint32_t", "binding", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const size_t>(object.descriptorOffset, settings, "size_t", "descriptorOffset", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const uint32_t>(object.descriptorSize, settings, "uint32_t", "descriptorSize", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.depthClampZeroOne, settings, "VkBool32", "depthClampZeroOne", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.nonSeamlessCubeMap, settings, "VkBool32", "nonSeamlessCubeMap", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.renderPassStriped, settings, "VkBool32", "renderPassStriped", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.renderPassStripeGranularity, settings, "VkExtent2D", "renderPassStripeGranularity", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.maxRenderPassStripes, settings, "uint32_t", "maxRenderPassStripes", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkRect2D>(object.stripeArea, settings, "VkRect2D", "stripeArea", indents + 1, dump_text_VkRect2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stripeInfoCount, settings, "uint32_t", "stripeInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRenderPassStripeInfoARM>(object.pStripeInfos, object.stripeInfoCount, settings, "const VkRenderPassStripeInfoARM*", "const VkRenderPassStripeInfoARM", "pStripeInfos", indents + 1, dump_text_VkRenderPassStripeInfoARM); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.stripeSemaphoreInfoCount, settings, "uint32_t", "stripeSemaphoreInfoCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkSemaphoreSubmitInfo>(object.pStripeSemaphoreInfos, object.stripeSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "const VkSemaphoreSubmitInfo", "pStripeSemaphoreInfos", indents + 1, dump_text_VkSemaphoreSubmitInfo); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.fragmentDensityMapOffset, settings, "VkBool32", "fragmentDensityMapOffset", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.fragmentDensityOffsetGranularity, settings, "VkExtent2D", "fragmentDensityOffsetGranularity", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.fragmentDensityOffsetCount, settings, "uint32_t", "fragmentDensityOffsetCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkOffset2D>(object.pFragmentDensityOffsets, object.fragmentDensityOffsetCount, settings, "const VkOffset2D*", "const VkOffset2D", "pFragmentDensityOffsets", indents + 1, dump_text_VkOffset2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCopyMemoryIndirectCommandNV(const VkCopyMemoryIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkCopyMemoryToImageIndirectCommandNV(const VkCopyMemoryToImageIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkImageSubresourceLayers>(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + 1, dump_text_VkImageSubresourceLayers);  // AET
    dump_text_value<const VkOffset3D>(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + 1, dump_text_VkOffset3D);  // AET
    dump_text_value<const VkExtent3D>(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + 1, dump_text_VkExtent3D);  // AET
}
void dump_text_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.indirectCopy, settings, "VkBool32", "indirectCopy", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkQueueFlags>(object.supportedQueues, settings, "VkQueueFlags", "supportedQueues", indents + 1, dump_text_VkQueueFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.compressedSize, settings, "VkDeviceSize", "compressedSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.decompressedSize, settings, "VkDeviceSize", "decompressedSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkMemoryDecompressionMethodFlagsNV>(object.decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsNV", "decompressionMethod", indents + 1, dump_text_VkMemoryDecompressionMethodFlagsNV);  // AET
}
void dump_text_VkPhysicalDeviceMemoryDecompressionFeaturesNV(const VkPhysicalDeviceMemoryDecompressionFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.memoryDecompression, settings, "VkBool32", "memoryDecompression", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMemoryDecompressionPropertiesNV(const VkPhysicalDeviceMemoryDecompressionPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkMemoryDecompressionMethodFlagsNV>(object.decompressionMethods, settings, "VkMemoryDecompressionMethodFlagsNV", "decompressionMethods", indents + 1, dump_text_VkMemoryDecompressionMethodFlagsNV);  // AET
    dump_text_value<const uint64_t>(object.maxDecompressionIndirectCount, settings, "uint64_t", "maxDecompressionIndirectCount", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceGeneratedCompute, settings, "VkBool32", "deviceGeneratedCompute", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.deviceGeneratedComputePipelines, settings, "VkBool32", "deviceGeneratedComputePipelines", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.deviceGeneratedComputeCaptureReplay, settings, "VkBool32", "deviceGeneratedComputeCaptureReplay", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddress>(object.pipelineDeviceAddressCaptureReplay, settings, "VkDeviceAddress", "pipelineDeviceAddressCaptureReplay", indents + 1, dump_text_VkDeviceAddress);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipelineBindPoint>(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + 1, dump_text_VkPipelineBindPoint);  // AET
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindPipelineIndirectCommandNV(const VkBindPipelineIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.pipelineAddress, settings, "VkDeviceAddress", "pipelineAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.spheres, settings, "VkBool32", "spheres", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.linearSweptSpheres, settings, "VkBool32", "linearSweptSpheres", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(const VkAccelerationStructureGeometryLinearSweptSpheresDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkFormat>(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkRayTracingLssIndexingModeNV>(object.indexingMode, settings, "VkRayTracingLssIndexingModeNV", "indexingMode", indents + 1, dump_text_VkRayTracingLssIndexingModeNV);  // AET
    dump_text_value<const VkRayTracingLssPrimitiveEndCapsModeNV>(object.endCapsMode, settings, "VkRayTracingLssPrimitiveEndCapsModeNV", "endCapsMode", indents + 1, dump_text_VkRayTracingLssPrimitiveEndCapsModeNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAccelerationStructureGeometrySpheresDataNV(const VkAccelerationStructureGeometrySpheresDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkFormat>(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_value<const VkDeviceSize>(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.linearColorAttachment, settings, "VkBool32", "linearColorAttachment", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderMaximalReconvergence, settings, "VkBool32", "shaderMaximalReconvergence", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imageCompressionControlSwapchain, settings, "VkBool32", "imageCompressionControlSwapchain", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkOffset2D>(object.filterCenter, settings, "VkOffset2D", "filterCenter", indents + 1, dump_text_VkOffset2D);  // AET
    dump_text_value<const VkExtent2D>(object.filterSize, settings, "VkExtent2D", "filterSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const uint32_t>(object.numPhases, settings, "uint32_t", "numPhases", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.textureSampleWeighted, settings, "VkBool32", "textureSampleWeighted", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureBoxFilter, settings, "VkBool32", "textureBoxFilter", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.textureBlockMatch, settings, "VkBool32", "textureBlockMatch", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxWeightFilterPhases, settings, "uint32_t", "maxWeightFilterPhases", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkExtent2D>(object.maxWeightFilterDimension, settings, "VkExtent2D", "maxWeightFilterDimension", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxBlockMatchRegion, settings, "VkExtent2D", "maxBlockMatchRegion", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxBoxFilterBlockSize, settings, "VkExtent2D", "maxBoxFilterBlockSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.nestedCommandBuffer, settings, "VkBool32", "nestedCommandBuffer", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nestedCommandBufferRendering, settings, "VkBool32", "nestedCommandBufferRendering", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.nestedCommandBufferSimultaneousUse, settings, "VkBool32", "nestedCommandBufferSimultaneousUse", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxCommandBufferNestingLevel, settings, "uint32_t", "maxCommandBufferNestingLevel", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.acquireUnmodifiedMemory, settings, "VkBool32", "acquireUnmodifiedMemory", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.extendedDynamicState3TessellationDomainOrigin, settings, "VkBool32", "extendedDynamicState3TessellationDomainOrigin", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3DepthClampEnable, settings, "VkBool32", "extendedDynamicState3DepthClampEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3PolygonMode, settings, "VkBool32", "extendedDynamicState3PolygonMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3RasterizationSamples, settings, "VkBool32", "extendedDynamicState3RasterizationSamples", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3SampleMask, settings, "VkBool32", "extendedDynamicState3SampleMask", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3AlphaToCoverageEnable, settings, "VkBool32", "extendedDynamicState3AlphaToCoverageEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3AlphaToOneEnable, settings, "VkBool32", "extendedDynamicState3AlphaToOneEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3LogicOpEnable, settings, "VkBool32", "extendedDynamicState3LogicOpEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ColorBlendEnable, settings, "VkBool32", "extendedDynamicState3ColorBlendEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ColorBlendEquation, settings, "VkBool32", "extendedDynamicState3ColorBlendEquation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ColorWriteMask, settings, "VkBool32", "extendedDynamicState3ColorWriteMask", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3RasterizationStream, settings, "VkBool32", "extendedDynamicState3RasterizationStream", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ConservativeRasterizationMode, settings, "VkBool32", "extendedDynamicState3ConservativeRasterizationMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ExtraPrimitiveOverestimationSize, settings, "VkBool32", "extendedDynamicState3ExtraPrimitiveOverestimationSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3DepthClipEnable, settings, "VkBool32", "extendedDynamicState3DepthClipEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3SampleLocationsEnable, settings, "VkBool32", "extendedDynamicState3SampleLocationsEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ColorBlendAdvanced, settings, "VkBool32", "extendedDynamicState3ColorBlendAdvanced", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ProvokingVertexMode, settings, "VkBool32", "extendedDynamicState3ProvokingVertexMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3LineRasterizationMode, settings, "VkBool32", "extendedDynamicState3LineRasterizationMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3LineStippleEnable, settings, "VkBool32", "extendedDynamicState3LineStippleEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3DepthClipNegativeOneToOne, settings, "VkBool32", "extendedDynamicState3DepthClipNegativeOneToOne", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ViewportWScalingEnable, settings, "VkBool32", "extendedDynamicState3ViewportWScalingEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ViewportSwizzle, settings, "VkBool32", "extendedDynamicState3ViewportSwizzle", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageToColorEnable, settings, "VkBool32", "extendedDynamicState3CoverageToColorEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageToColorLocation, settings, "VkBool32", "extendedDynamicState3CoverageToColorLocation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageModulationMode, settings, "VkBool32", "extendedDynamicState3CoverageModulationMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageModulationTableEnable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTableEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageModulationTable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3CoverageReductionMode, settings, "VkBool32", "extendedDynamicState3CoverageReductionMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3RepresentativeFragmentTestEnable, settings, "VkBool32", "extendedDynamicState3RepresentativeFragmentTestEnable", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.extendedDynamicState3ShadingRateImageEnable, settings, "VkBool32", "extendedDynamicState3ShadingRateImageEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.dynamicPrimitiveTopologyUnrestricted, settings, "VkBool32", "dynamicPrimitiveTopologyUnrestricted", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkColorBlendEquationEXT(const VkColorBlendEquationEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBlendFactor>(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendFactor>(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendOp>(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + 1, dump_text_VkBlendOp);  // AET
    dump_text_value<const VkBlendFactor>(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendFactor>(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + 1, dump_text_VkBlendFactor);  // AET
    dump_text_value<const VkBlendOp>(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + 1, dump_text_VkBlendOp);  // AET
}
void dump_text_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkBlendOp>(object.advancedBlendOp, settings, "VkBlendOp", "advancedBlendOp", indents + 1, dump_text_VkBlendOp);  // AET
    dump_text_value<const VkBool32>(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBlendOverlapEXT>(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + 1, dump_text_VkBlendOverlapEXT);  // AET
    dump_text_value<const VkBool32>(object.clampResults, settings, "VkBool32", "clampResults", indents + 1, dump_text_VkBool32);  // AET
}
void dump_text_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.subpassMergeFeedback, settings, "VkBool32", "subpassMergeFeedback", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.disallowMerging, settings, "VkBool32", "disallowMerging", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.postMergeSubpassCount, settings, "uint32_t", "postMergeSubpassCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkRenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkRenderPassCreationFeedbackInfoEXT>(object.pRenderPassFeedback, settings, "VkRenderPassCreationFeedbackInfoEXT*", "pRenderPassFeedback", indents + 1, dump_text_VkRenderPassCreationFeedbackInfoEXT);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkSubpassMergeStatusEXT>(object.subpassMergeStatus, settings, "VkSubpassMergeStatusEXT", "subpassMergeStatus", indents + 1, dump_text_VkSubpassMergeStatusEXT);  // AET
    dump_text_value<const char*>(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.postMergeIndex, settings, "uint32_t", "postMergeIndex", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkRenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkRenderPassSubpassFeedbackInfoEXT>(object.pSubpassFeedback, settings, "VkRenderPassSubpassFeedbackInfoEXT*", "pSubpassFeedback", indents + 1, dump_text_VkRenderPassSubpassFeedbackInfoEXT);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDirectDriverLoadingFlagsLUNARG>(object.flags, settings, "VkDirectDriverLoadingFlagsLUNARG", "flags", indents + 1, dump_text_VkDirectDriverLoadingFlagsLUNARG);  // AET
    dump_text_value<const PFN_vkGetInstanceProcAddrLUNARG>(object.pfnGetInstanceProcAddr, settings, "PFN_vkGetInstanceProcAddrLUNARG", "pfnGetInstanceProcAddr", indents + 1, dump_text_PFN_vkGetInstanceProcAddrLUNARG);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDirectDriverLoadingModeLUNARG>(object.mode, settings, "VkDirectDriverLoadingModeLUNARG", "mode", indents + 1, dump_text_VkDirectDriverLoadingModeLUNARG);  // AET
    dump_text_value<const uint32_t>(object.driverCount, settings, "uint32_t", "driverCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDirectDriverLoadingInfoLUNARG>(object.pDrivers, object.driverCount, settings, "const VkDirectDriverLoadingInfoLUNARG*", "const VkDirectDriverLoadingInfoLUNARG", "pDrivers", indents + 1, dump_text_VkDirectDriverLoadingInfoLUNARG); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderModuleIdentifier, settings, "VkBool32", "shaderModuleIdentifier", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint8_t>(object.shaderModuleIdentifierAlgorithmUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "shaderModuleIdentifierAlgorithmUUID", indents + 1, dump_text_uint8_t); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.identifierSize, settings, "uint32_t", "identifierSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint8_t>(object.pIdentifier, object.identifierSize, settings, "const uint8_t*", "const uint8_t", "pIdentifier", indents + 1, dump_text_uint8_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.identifierSize, settings, "uint32_t", "identifierSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint8_t>(object.identifier, 32, settings, "uint8_t[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]", "uint8_t", "identifier", indents + 1, dump_text_uint8_t); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.opticalFlow, settings, "VkBool32", "opticalFlow", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkOpticalFlowGridSizeFlagsNV>(object.supportedOutputGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedOutputGridSizes", indents + 1, dump_text_VkOpticalFlowGridSizeFlagsNV);  // AET
    dump_text_value<const VkOpticalFlowGridSizeFlagsNV>(object.supportedHintGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedHintGridSizes", indents + 1, dump_text_VkOpticalFlowGridSizeFlagsNV);  // AET
    dump_text_value<const VkBool32>(object.hintSupported, settings, "VkBool32", "hintSupported", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.costSupported, settings, "VkBool32", "costSupported", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.bidirectionalFlowSupported, settings, "VkBool32", "bidirectionalFlowSupported", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.globalFlowSupported, settings, "VkBool32", "globalFlowSupported", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.minWidth, settings, "uint32_t", "minWidth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minHeight, settings, "uint32_t", "minHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxWidth, settings, "uint32_t", "maxWidth", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxHeight, settings, "uint32_t", "maxHeight", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxNumRegionsOfInterest, settings, "uint32_t", "maxNumRegionsOfInterest", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkOpticalFlowUsageFlagsNV>(object.usage, settings, "VkOpticalFlowUsageFlagsNV", "usage", indents + 1, dump_text_VkOpticalFlowUsageFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.width, settings, "uint32_t", "width", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.height, settings, "uint32_t", "height", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkFormat>(object.imageFormat, settings, "VkFormat", "imageFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkFormat>(object.flowVectorFormat, settings, "VkFormat", "flowVectorFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkFormat>(object.costFormat, settings, "VkFormat", "costFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const VkOpticalFlowGridSizeFlagsNV>(object.outputGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "outputGridSize", indents + 1, dump_text_VkOpticalFlowGridSizeFlagsNV);  // AET
    dump_text_value<const VkOpticalFlowGridSizeFlagsNV>(object.hintGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "hintGridSize", indents + 1, dump_text_VkOpticalFlowGridSizeFlagsNV);  // AET
    dump_text_value<const VkOpticalFlowPerformanceLevelNV>(object.performanceLevel, settings, "VkOpticalFlowPerformanceLevelNV", "performanceLevel", indents + 1, dump_text_VkOpticalFlowPerformanceLevelNV);  // AET
    dump_text_value<const VkOpticalFlowSessionCreateFlagsNV>(object.flags, settings, "VkOpticalFlowSessionCreateFlagsNV", "flags", indents + 1, dump_text_VkOpticalFlowSessionCreateFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.id, settings, "uint32_t", "id", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pPrivateData, settings, "const void*", "pPrivateData", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkOpticalFlowExecuteFlagsNV>(object.flags, settings, "VkOpticalFlowExecuteFlagsNV", "flags", indents + 1, dump_text_VkOpticalFlowExecuteFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.regionCount, settings, "uint32_t", "regionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pRegions, object.regionCount, settings, "const VkRect2D*", "const VkRect2D", "pRegions", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.legacyDithering, settings, "VkBool32", "legacyDithering", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.externalFormatResolve, settings, "VkBool32", "externalFormatResolve", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.nullColorAttachmentWithExternalFormatResolve, settings, "VkBool32", "nullColorAttachmentWithExternalFormatResolve", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkChromaLocation>(object.externalFormatResolveChromaOffsetX, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetX", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.externalFormatResolveChromaOffsetY, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetY", indents + 1, dump_text_VkChromaLocation);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.colorAttachmentFormat, settings, "VkFormat", "colorAttachmentFormat", indents + 1, dump_text_VkFormat);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
void dump_text_VkPhysicalDeviceAntiLagFeaturesAMD(const VkPhysicalDeviceAntiLagFeaturesAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.antiLag, settings, "VkBool32", "antiLag", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkAntiLagStageAMD>(object.stage, settings, "VkAntiLagStageAMD", "stage", indents + 1, dump_text_VkAntiLagStageAMD);  // AET
    dump_text_value<const uint64_t>(object.frameIndex, settings, "uint64_t", "frameIndex", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAntiLagDataAMD(const VkAntiLagDataAMD& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAntiLagModeAMD>(object.mode, settings, "VkAntiLagModeAMD", "mode", indents + 1, dump_text_VkAntiLagModeAMD);  // AET
    dump_text_value<const uint32_t>(object.maxFPS, settings, "uint32_t", "maxFPS", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const VkAntiLagPresentationInfoAMD>(object.pPresentationInfo, settings, "const VkAntiLagPresentationInfoAMD*", "pPresentationInfo", indents + 1, dump_text_VkAntiLagPresentationInfoAMD);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingPositionFetch, settings, "VkBool32", "rayTracingPositionFetch", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderObject, settings, "VkBool32", "shaderObject", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_array<const uint8_t>(object.shaderBinaryUUID, 16, settings, "uint8_t[VK_UUID_SIZE]", "uint8_t", "shaderBinaryUUID", indents + 1, dump_text_uint8_t); // AQA
    dump_text_value<const uint32_t>(object.shaderBinaryVersion, settings, "uint32_t", "shaderBinaryVersion", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderCreateFlagsEXT>(object.flags, settings, "VkShaderCreateFlagsEXT", "flags", indents + 1, dump_text_VkShaderCreateFlagsEXT);  // AET
    dump_text_value<const VkShaderStageFlagBits>(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + 1, dump_text_VkShaderStageFlagBits);  // AET
    dump_text_value<const VkShaderStageFlags>(object.nextStage, settings, "VkShaderStageFlags", "nextStage", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkShaderCodeTypeEXT>(object.codeType, settings, "VkShaderCodeTypeEXT", "codeType", indents + 1, dump_text_VkShaderCodeTypeEXT);  // AET
    dump_text_value<const size_t>(object.codeSize, settings, "size_t", "codeSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pCode, settings, "const void*", "pCode", indents + 1, dump_text_void);  // AET
    dump_text_value<const char*>(object.pName, settings, "const char*", "pName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSetLayout>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "const VkDescriptorSetLayout", "pSetLayouts", indents + 1, dump_text_VkDescriptorSetLayout); // BQB
    dump_text_value<const uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPushConstantRange>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "const VkPushConstantRange", "pPushConstantRanges", indents + 1, dump_text_VkPushConstantRange); // BQB
    dump_text_pointer<const VkSpecializationInfo>(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + 1, dump_text_VkSpecializationInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDepthClampRangeEXT(const VkDepthClampRangeEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const float>(object.minDepthClamp, settings, "float", "minDepthClamp", indents + 1, dump_text_float);  // AET
    dump_text_value<const float>(object.maxDepthClamp, settings, "float", "maxDepthClamp", indents + 1, dump_text_float);  // AET
}
void dump_text_VkPhysicalDevicePipelineBinaryFeaturesKHR(const VkPhysicalDevicePipelineBinaryFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineBinaries, settings, "VkBool32", "pipelineBinaries", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineBinaryPropertiesKHR(const VkPhysicalDevicePipelineBinaryPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineBinaryInternalCache, settings, "VkBool32", "pipelineBinaryInternalCache", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineBinaryInternalCacheControl, settings, "VkBool32", "pipelineBinaryInternalCacheControl", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineBinaryPrefersInternalCache, settings, "VkBool32", "pipelineBinaryPrefersInternalCache", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineBinaryPrecompiledInternalCache, settings, "VkBool32", "pipelineBinaryPrecompiledInternalCache", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.pipelineBinaryCompressedData, settings, "VkBool32", "pipelineBinaryCompressedData", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDevicePipelineBinaryInternalCacheControlKHR(const VkDevicePipelineBinaryInternalCacheControlKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.disableInternalCache, settings, "VkBool32", "disableInternalCache", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.keySize, settings, "uint32_t", "keySize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint8_t>(object.key, 32, settings, "uint8_t[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]", "uint8_t", "key", indents + 1, dump_text_uint8_t); // AQA
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const size_t>(object.dataSize, settings, "size_t", "dataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pData, settings, "void*", "pData", indents + 1, dump_text_void);  // AET
}
void dump_text_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.binaryCount, settings, "uint32_t", "binaryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineBinaryKeyKHR>(object.pPipelineBinaryKeys, object.binaryCount, settings, "const VkPipelineBinaryKeyKHR*", "const VkPipelineBinaryKeyKHR", "pPipelineBinaryKeys", indents + 1, dump_text_VkPipelineBinaryKeyKHR); // BQB
    dump_text_array<const VkPipelineBinaryDataKHR>(object.pPipelineBinaryData, object.binaryCount, settings, "const VkPipelineBinaryDataKHR*", "const VkPipelineBinaryDataKHR", "pPipelineBinaryData", indents + 1, dump_text_VkPipelineBinaryDataKHR); // BQB
}
void dump_text_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const VkPipelineBinaryKeysAndDataKHR>(object.pKeysAndDataInfo, settings, "const VkPipelineBinaryKeysAndDataKHR*", "pKeysAndDataInfo", indents + 1, dump_text_VkPipelineBinaryKeysAndDataKHR);
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_pointer<const VkPipelineCreateInfoKHR>(object.pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", indents + 1, dump_text_VkPipelineCreateInfoKHR);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.binaryCount, settings, "uint32_t", "binaryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineBinaryKHR>(object.pPipelineBinaries, object.binaryCount, settings, "const VkPipelineBinaryKHR*", "const VkPipelineBinaryKHR", "pPipelineBinaries", indents + 1, dump_text_VkPipelineBinaryKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkReleaseCapturedPipelineDataInfoKHR(const VkReleaseCapturedPipelineDataInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipelineBinaryKHR>(object.pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", indents + 1, dump_text_VkPipelineBinaryKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.pipelineBinaryCount, settings, "uint32_t", "pipelineBinaryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPipelineBinaryKHR>(object.pPipelineBinaries, object.pipelineBinaryCount, settings, "VkPipelineBinaryKHR*", "VkPipelineBinaryKHR", "pPipelineBinaries", indents + 1, dump_text_VkPipelineBinaryKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.tileProperties, settings, "VkBool32", "tileProperties", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTilePropertiesQCOM(const VkTilePropertiesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent3D>(object.tileSize, settings, "VkExtent3D", "tileSize", indents + 1, dump_text_VkExtent3D);  // AET
    dump_text_value<const VkExtent2D>(object.apronSize, settings, "VkExtent2D", "apronSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkOffset2D>(object.origin, settings, "VkOffset2D", "origin", indents + 1, dump_text_VkOffset2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.amigoProfiling, settings, "VkBool32", "amigoProfiling", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.firstDrawTimestamp, settings, "uint64_t", "firstDrawTimestamp", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.swapBufferTimestamp, settings, "uint64_t", "swapBufferTimestamp", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.multiviewPerViewViewports, settings, "VkBool32", "multiviewPerViewViewports", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkRayTracingInvocationReorderModeNV>(object.rayTracingInvocationReorderReorderingHint, settings, "VkRayTracingInvocationReorderModeNV", "rayTracingInvocationReorderReorderingHint", indents + 1, dump_text_VkRayTracingInvocationReorderModeNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingInvocationReorder, settings, "VkBool32", "rayTracingInvocationReorder", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeVectorPropertiesNV(const VkPhysicalDeviceCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderStageFlags>(object.cooperativeVectorSupportedStages, settings, "VkShaderStageFlags", "cooperativeVectorSupportedStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkBool32>(object.cooperativeVectorTrainingFloat16Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat16Accumulation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeVectorTrainingFloat32Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat32Accumulation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxCooperativeVectorComponents, settings, "uint32_t", "maxCooperativeVectorComponents", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeVectorFeaturesNV(const VkPhysicalDeviceCooperativeVectorFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cooperativeVector, settings, "VkBool32", "cooperativeVector", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeVectorTraining, settings, "VkBool32", "cooperativeVectorTraining", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkComponentTypeKHR>(object.inputType, settings, "VkComponentTypeKHR", "inputType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.inputInterpretation, settings, "VkComponentTypeKHR", "inputInterpretation", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.matrixInterpretation, settings, "VkComponentTypeKHR", "matrixInterpretation", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.biasInterpretation, settings, "VkComponentTypeKHR", "biasInterpretation", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.resultType, settings, "VkComponentTypeKHR", "resultType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkBool32>(object.transpose, settings, "VkBool32", "transpose", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkConvertCooperativeVectorMatrixInfoNV(const VkConvertCooperativeVectorMatrixInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const size_t>(object.srcSize, settings, "size_t", "srcSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const VkDeviceOrHostAddressConstKHR>(object.srcData, settings, "VkDeviceOrHostAddressConstKHR", "srcData", indents + 1, dump_text_VkDeviceOrHostAddressConstKHR);  // AET
    dump_text_pointer<const size_t>(object.pDstSize, settings, "size_t*", "pDstSize", indents + 1, dump_text_size_t);
    dump_text_value<const VkDeviceOrHostAddressKHR>(object.dstData, settings, "VkDeviceOrHostAddressKHR", "dstData", indents + 1, dump_text_VkDeviceOrHostAddressKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.srcComponentType, settings, "VkComponentTypeKHR", "srcComponentType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.dstComponentType, settings, "VkComponentTypeKHR", "dstComponentType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const uint32_t>(object.numRows, settings, "uint32_t", "numRows", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.numColumns, settings, "uint32_t", "numColumns", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkCooperativeVectorMatrixLayoutNV>(object.srcLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "srcLayout", indents + 1, dump_text_VkCooperativeVectorMatrixLayoutNV);  // AET
    dump_text_value<const size_t>(object.srcStride, settings, "size_t", "srcStride", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const VkCooperativeVectorMatrixLayoutNV>(object.dstLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "dstLayout", indents + 1, dump_text_VkCooperativeVectorMatrixLayoutNV);  // AET
    dump_text_value<const size_t>(object.dstStride, settings, "size_t", "dstStride", indents + 1, dump_text_size_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.extendedSparseAddressSpace, settings, "VkBool32", "extendedSparseAddressSpace", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.extendedSparseAddressSpaceSize, settings, "VkDeviceSize", "extendedSparseAddressSpaceSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkImageUsageFlags>(object.extendedSparseImageUsageFlags, settings, "VkImageUsageFlags", "extendedSparseImageUsageFlags", indents + 1, dump_text_VkImageUsageFlags);  // AET
    dump_text_value<const VkBufferUsageFlags>(object.extendedSparseBufferUsageFlags, settings, "VkBufferUsageFlags", "extendedSparseBufferUsageFlags", indents + 1, dump_text_VkBufferUsageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.legacyVertexAttributes, settings, "VkBool32", "legacyVertexAttributes", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.nativeUnalignedPerformance, settings, "VkBool32", "nativeUnalignedPerformance", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLayerSettingEXT(const VkLayerSettingEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const char*>(object.pLayerName, settings, "const char*", "pLayerName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const char*>(object.pSettingName, settings, "const char*", "pSettingName", indents + 1, dump_text_cstring);  // AET
    dump_text_value<const VkLayerSettingTypeEXT>(object.type, settings, "VkLayerSettingTypeEXT", "type", indents + 1, dump_text_VkLayerSettingTypeEXT);  // AET
    dump_text_value<const uint32_t>(object.valueCount, settings, "uint32_t", "valueCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const void*>(object.pValues, settings, "const void*", "pValues", indents + 1, dump_text_void);  // AET
}
void dump_text_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.settingCount, settings, "uint32_t", "settingCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkLayerSettingEXT>(object.pSettings, object.settingCount, settings, "const VkLayerSettingEXT*", "const VkLayerSettingEXT", "pSettings", indents + 1, dump_text_VkLayerSettingEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderCoreBuiltins, settings, "VkBool32", "shaderCoreBuiltins", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.shaderCoreMask, settings, "uint64_t", "shaderCoreMask", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint32_t>(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.shaderWarpsPerCore, settings, "uint32_t", "shaderWarpsPerCore", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineLibraryGroupHandles, settings, "VkBool32", "pipelineLibraryGroupHandles", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.dynamicRenderingUnusedAttachments, settings, "VkBool32", "dynamicRenderingUnusedAttachments", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.lowLatencyMode, settings, "VkBool32", "lowLatencyMode", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.lowLatencyBoost, settings, "VkBool32", "lowLatencyBoost", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.minimumIntervalUs, settings, "uint32_t", "minimumIntervalUs", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLatencySleepInfoNV(const VkLatencySleepInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkSemaphore>(object.signalSemaphore, settings, "VkSemaphore", "signalSemaphore", indents + 1, dump_text_VkSemaphore);  // AET
    dump_text_value<const uint64_t>(object.value, settings, "uint64_t", "value", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkLatencyMarkerNV>(object.marker, settings, "VkLatencyMarkerNV", "marker", indents + 1, dump_text_VkLatencyMarkerNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.inputSampleTimeUs, settings, "uint64_t", "inputSampleTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.simStartTimeUs, settings, "uint64_t", "simStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.simEndTimeUs, settings, "uint64_t", "simEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.renderSubmitStartTimeUs, settings, "uint64_t", "renderSubmitStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.renderSubmitEndTimeUs, settings, "uint64_t", "renderSubmitEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.presentStartTimeUs, settings, "uint64_t", "presentStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.presentEndTimeUs, settings, "uint64_t", "presentEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.driverStartTimeUs, settings, "uint64_t", "driverStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.driverEndTimeUs, settings, "uint64_t", "driverEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.osRenderQueueStartTimeUs, settings, "uint64_t", "osRenderQueueStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.osRenderQueueEndTimeUs, settings, "uint64_t", "osRenderQueueEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.gpuRenderStartTimeUs, settings, "uint64_t", "gpuRenderStartTimeUs", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.gpuRenderEndTimeUs, settings, "uint64_t", "gpuRenderEndTimeUs", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.timingCount, settings, "uint32_t", "timingCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkLatencyTimingsFrameReportNV>(object.pTimings, object.timingCount, settings, "VkLatencyTimingsFrameReportNV*", "VkLatencyTimingsFrameReportNV", "pTimings", indents + 1, dump_text_VkLatencyTimingsFrameReportNV); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint64_t>(object.presentID, settings, "uint64_t", "presentID", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.latencyModeEnable, settings, "VkBool32", "latencyModeEnable", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkOutOfBandQueueTypeNV>(object.queueType, settings, "VkOutOfBandQueueTypeNV", "queueType", indents + 1, dump_text_VkOutOfBandQueueTypeNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPresentModeKHR>(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "VkPresentModeKHR", "pPresentModes", indents + 1, dump_text_VkPresentModeKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.MSize, settings, "uint32_t", "MSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.NSize, settings, "uint32_t", "NSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.KSize, settings, "uint32_t", "KSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.AType, settings, "VkComponentTypeKHR", "AType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.BType, settings, "VkComponentTypeKHR", "BType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.CType, settings, "VkComponentTypeKHR", "CType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkBool32>(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkScopeKHR>(object.scope, settings, "VkScopeKHR", "scope", indents + 1, dump_text_VkScopeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkShaderStageFlags>(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.multiviewPerViewRenderAreas, settings, "VkBool32", "multiviewPerViewRenderAreas", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.perViewRenderAreaCount, settings, "uint32_t", "perViewRenderAreaCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkRect2D>(object.pPerViewRenderAreas, object.perViewRenderAreaCount, settings, "const VkRect2D*", "const VkRect2D", "pPerViewRenderAreas", indents + 1, dump_text_VkRect2D); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.meshAndTaskShaderDerivatives, settings, "VkBool32", "meshAndTaskShaderDerivatives", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoAV1Profile>(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + 1, dump_text_StdVideoAV1Profile);  // AET
    dump_text_value<const VkBool32>(object.filmGrainSupport, settings, "VkBool32", "filmGrainSupport", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const StdVideoAV1Level>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + 1, dump_text_StdVideoAV1Level);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoAV1SequenceHeader>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + 1, dump_text_StdVideoAV1SequenceHeader);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeAV1PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoDecodeAV1PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoDecodeAV1PictureInfo);
    dump_text_array<const int32_t>(object.referenceNameSlotIndices, 7, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "int32_t", "referenceNameSlotIndices", indents + 1, dump_text_int32_t); // AQA
    dump_text_value<const uint32_t>(object.frameHeaderOffset, settings, "uint32_t", "frameHeaderOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.tileCount, settings, "uint32_t", "tileCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pTileOffsets, object.tileCount, settings, "const uint32_t*", "const uint32_t", "pTileOffsets", indents + 1, dump_text_uint32_t); // BQB
    dump_text_array<const uint32_t>(object.pTileSizes, object.tileCount, settings, "const uint32_t*", "const uint32_t", "pTileSizes", indents + 1, dump_text_uint32_t); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoDecodeAV1ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoDecodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoDecodeAV1ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.videoEncodeAV1, settings, "VkBool32", "videoEncodeAV1", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeAV1CapabilityFlagsKHR>(object.flags, settings, "VkVideoEncodeAV1CapabilityFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeAV1CapabilityFlagsKHR);  // AET
    dump_text_value<const StdVideoAV1Level>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + 1, dump_text_StdVideoAV1Level);  // AET
    dump_text_value<const VkExtent2D>(object.codedPictureAlignment, settings, "VkExtent2D", "codedPictureAlignment", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.minTileSize, settings, "VkExtent2D", "minTileSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkExtent2D>(object.maxTileSize, settings, "VkExtent2D", "maxTileSize", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkVideoEncodeAV1SuperblockSizeFlagsKHR>(object.superblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "superblockSizes", indents + 1, dump_text_VkVideoEncodeAV1SuperblockSizeFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.maxSingleReferenceCount, settings, "uint32_t", "maxSingleReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.singleReferenceNameMask, settings, "uint32_t", "singleReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundGroup1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.unidirectionalCompoundReferenceNameMask, settings, "uint32_t", "unidirectionalCompoundReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBidirectionalCompoundReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup2ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bidirectionalCompoundReferenceNameMask, settings, "uint32_t", "bidirectionalCompoundReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxSpatialLayerCount, settings, "uint32_t", "maxSpatialLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxOperatingPoints, settings, "uint32_t", "maxOperatingPoints", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minQIndex, settings, "uint32_t", "minQIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxQIndex, settings, "uint32_t", "maxQIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBool32>(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeAV1StdFlagsKHR>(object.stdSyntaxFlags, settings, "VkVideoEncodeAV1StdFlagsKHR", "stdSyntaxFlags", indents + 1, dump_text_VkVideoEncodeAV1StdFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1QIndexKHR(const VkVideoEncodeAV1QIndexKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.intraQIndex, settings, "uint32_t", "intraQIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.predictiveQIndex, settings, "uint32_t", "predictiveQIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bipredictiveQIndex, settings, "uint32_t", "bipredictiveQIndex", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkVideoEncodeAV1QualityLevelPropertiesKHR(const VkVideoEncodeAV1QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeAV1RateControlFlagsKHR>(object.preferredRateControlFlags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "preferredRateControlFlags", indents + 1, dump_text_VkVideoEncodeAV1RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredKeyFramePeriod, settings, "uint32_t", "preferredKeyFramePeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredConsecutiveBipredictiveFrameCount, settings, "uint32_t", "preferredConsecutiveBipredictiveFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkVideoEncodeAV1QIndexKHR>(object.preferredConstantQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "preferredConstantQIndex", indents + 1, dump_text_VkVideoEncodeAV1QIndexKHR);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxSingleReferenceCount, settings, "uint32_t", "preferredMaxSingleReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredSingleReferenceNameMask, settings, "uint32_t", "preferredSingleReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundGroup1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredUnidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredUnidirectionalCompoundReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxBidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup1ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredMaxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup2ReferenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.preferredBidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredBidirectionalCompoundReferenceNameMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1SessionCreateInfoKHR(const VkVideoEncodeAV1SessionCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMaxLevel, settings, "VkBool32", "useMaxLevel", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const StdVideoAV1Level>(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + 1, dump_text_StdVideoAV1Level);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const VkVideoEncodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoAV1SequenceHeader>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + 1, dump_text_StdVideoAV1SequenceHeader);
    dump_text_pointer<const StdVideoEncodeAV1DecoderModelInfo>(object.pStdDecoderModelInfo, settings, "const StdVideoEncodeAV1DecoderModelInfo*", "pStdDecoderModelInfo", indents + 1, dump_text_StdVideoEncodeAV1DecoderModelInfo);
    dump_text_value<const uint32_t>(object.stdOperatingPointCount, settings, "uint32_t", "stdOperatingPointCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const StdVideoEncodeAV1OperatingPointInfo>(object.pStdOperatingPoints, object.stdOperatingPointCount, settings, "const StdVideoEncodeAV1OperatingPointInfo*", "const StdVideoEncodeAV1OperatingPointInfo", "pStdOperatingPoints", indents + 1, dump_text_StdVideoEncodeAV1OperatingPointInfo); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeAV1PredictionModeKHR>(object.predictionMode, settings, "VkVideoEncodeAV1PredictionModeKHR", "predictionMode", indents + 1, dump_text_VkVideoEncodeAV1PredictionModeKHR);  // AET
    dump_text_value<const VkVideoEncodeAV1RateControlGroupKHR>(object.rateControlGroup, settings, "VkVideoEncodeAV1RateControlGroupKHR", "rateControlGroup", indents + 1, dump_text_VkVideoEncodeAV1RateControlGroupKHR);  // AET
    dump_text_value<const uint32_t>(object.constantQIndex, settings, "uint32_t", "constantQIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_pointer<const StdVideoEncodeAV1PictureInfo>(object.pStdPictureInfo, settings, "const StdVideoEncodeAV1PictureInfo*", "pStdPictureInfo", indents + 1, dump_text_StdVideoEncodeAV1PictureInfo);
    dump_text_array<const int32_t>(object.referenceNameSlotIndices, 7, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "int32_t", "referenceNameSlotIndices", indents + 1, dump_text_int32_t); // AQA
    dump_text_value<const VkBool32>(object.primaryReferenceCdfOnly, settings, "VkBool32", "primaryReferenceCdfOnly", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.generateObuExtensionHeader, settings, "VkBool32", "generateObuExtensionHeader", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoEncodeAV1ReferenceInfo>(object.pStdReferenceInfo, settings, "const StdVideoEncodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + 1, dump_text_StdVideoEncodeAV1ReferenceInfo);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const StdVideoAV1Profile>(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + 1, dump_text_StdVideoAV1Profile);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1FrameSizeKHR(const VkVideoEncodeAV1FrameSizeKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.intraFrameSize, settings, "uint32_t", "intraFrameSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.predictiveFrameSize, settings, "uint32_t", "predictiveFrameSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.bipredictiveFrameSize, settings, "uint32_t", "bipredictiveFrameSize", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const VkVideoEncodeAV1GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingIntra, settings, "uint32_t", "gopRemainingIntra", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingPredictive, settings, "uint32_t", "gopRemainingPredictive", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.gopRemainingBipredictive, settings, "uint32_t", "gopRemainingBipredictive", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1RateControlInfoKHR(const VkVideoEncodeAV1RateControlInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkVideoEncodeAV1RateControlFlagsKHR>(object.flags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "flags", indents + 1, dump_text_VkVideoEncodeAV1RateControlFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.keyFramePeriod, settings, "uint32_t", "keyFramePeriod", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.consecutiveBipredictiveFrameCount, settings, "uint32_t", "consecutiveBipredictiveFrameCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.useMinQIndex, settings, "VkBool32", "useMinQIndex", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeAV1QIndexKHR>(object.minQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "minQIndex", indents + 1, dump_text_VkVideoEncodeAV1QIndexKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxQIndex, settings, "VkBool32", "useMaxQIndex", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeAV1QIndexKHR>(object.maxQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "maxQIndex", indents + 1, dump_text_VkVideoEncodeAV1QIndexKHR);  // AET
    dump_text_value<const VkBool32>(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkVideoEncodeAV1FrameSizeKHR>(object.maxFrameSize, settings, "VkVideoEncodeAV1FrameSizeKHR", "maxFrameSize", indents + 1, dump_text_VkVideoEncodeAV1FrameSizeKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.videoMaintenance1, settings, "VkBool32", "videoMaintenance1", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueryPool>(object.queryPool, settings, "VkQueryPool", "queryPool", indents + 1, dump_text_VkQueryPool);  // AET
    dump_text_value<const uint32_t>(object.firstQuery, settings, "uint32_t", "firstQuery", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.queryCount, settings, "uint32_t", "queryCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.perStageDescriptorSet, settings, "VkBool32", "perStageDescriptorSet", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dynamicPipelineLayout, settings, "VkBool32", "dynamicPipelineLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.textureBlockMatch2, settings, "VkBool32", "textureBlockMatch2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.maxBlockMatchWindow, settings, "VkExtent2D", "maxBlockMatchWindow", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExtent2D>(object.windowExtent, settings, "VkExtent2D", "windowExtent", indents + 1, dump_text_VkExtent2D);  // AET
    dump_text_value<const VkBlockMatchWindowCompareModeQCOM>(object.windowCompareMode, settings, "VkBlockMatchWindowCompareModeQCOM", "windowCompareMode", indents + 1, dump_text_VkBlockMatchWindowCompareModeQCOM);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.selectableCubicWeights, settings, "VkBool32", "selectableCubicWeights", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCubicFilterWeightsQCOM>(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + 1, dump_text_VkCubicFilterWeightsQCOM);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkCubicFilterWeightsQCOM>(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + 1, dump_text_VkCubicFilterWeightsQCOM);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.ycbcrDegamma, settings, "VkBool32", "ycbcrDegamma", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.enableYDegamma, settings, "VkBool32", "enableYDegamma", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.enableCbCrDegamma, settings, "VkBool32", "enableCbCrDegamma", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cubicRangeClamp, settings, "VkBool32", "cubicRangeClamp", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.attachmentFeedbackLoopDynamicState, settings, "VkBool32", "attachmentFeedbackLoopDynamicState", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.format, settings, "VkFormat", "format", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const uint64_t>(object.screenUsage, settings, "uint64_t", "screenUsage", indents + 1, dump_text_uint64_t);  // AET
    dump_text_value<const VkFormatFeatureFlags>(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + 1, dump_text_VkFormatFeatureFlags);  // AET
    dump_text_value<const VkComponentMapping>(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + 1, dump_text_VkComponentMapping);  // AET
    dump_text_value<const VkSamplerYcbcrModelConversion>(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + 1, dump_text_VkSamplerYcbcrModelConversion);  // AET
    dump_text_value<const VkSamplerYcbcrRange>(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + 1, dump_text_VkSamplerYcbcrRange);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    dump_text_value<const VkChromaLocation>(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + 1, dump_text_VkChromaLocation);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const _screen_buffer*>(object.buffer, settings, "struct _screen_buffer*", "buffer", indents + 1, dump_text__screen_buffer);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkExternalFormatQNX(const VkExternalFormatQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint64_t>(object.externalFormat, settings, "uint64_t", "externalFormat", indents + 1, dump_text_uint64_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.screenBufferImport, settings, "VkBool32", "screenBufferImport", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
void dump_text_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkLayeredDriverUnderlyingApiMSFT>(object.underlyingAPI, settings, "VkLayeredDriverUnderlyingApiMSFT", "underlyingAPI", indents + 1, dump_text_VkLayeredDriverUnderlyingApiMSFT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkSetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.firstSet, settings, "uint32_t", "firstSet", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.setCount, settings, "uint32_t", "setCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const uint32_t>(object.pBufferIndices, object.setCount, settings, "const uint32_t*", "const uint32_t", "pBufferIndices", indents + 1, dump_text_uint32_t); // BQB
    dump_text_array<const VkDeviceSize>(object.pOffsets, object.setCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", indents + 1, dump_text_VkDeviceSize); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderStageFlags>(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkPipelineLayout>(object.layout, settings, "VkPipelineLayout", "layout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.set, settings, "uint32_t", "set", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.descriptorPoolOverallocation, settings, "VkBool32", "descriptorPoolOverallocation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.tileMemoryHeap, settings, "VkBool32", "tileMemoryHeap", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.queueSubmitBoundary, settings, "VkBool32", "queueSubmitBoundary", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.tileBufferTransfers, settings, "VkBool32", "tileBufferTransfers", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceSize>(object.alignment, settings, "VkDeviceSize", "alignment", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceSize>(object.size, settings, "VkDeviceSize", "size", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplaySurfaceStereoCreateInfoNV(const VkDisplaySurfaceStereoCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDisplaySurfaceStereoTypeNV>(object.stereoType, settings, "VkDisplaySurfaceStereoTypeNV", "stereoType", indents + 1, dump_text_VkDisplaySurfaceStereoTypeNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkBool32>(object.hdmi3DSupported, settings, "VkBool32", "hdmi3DSupported", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeQuantizationMapCapabilitiesKHR(const VkVideoEncodeQuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.maxQuantizationMapExtent, settings, "VkExtent2D", "maxQuantizationMapExtent", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoFormatQuantizationMapPropertiesKHR(const VkVideoFormatQuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkExtent2D>(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeQuantizationMapInfoKHR(const VkVideoEncodeQuantizationMapInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkImageView>(object.quantizationMap, settings, "VkImageView", "quantizationMap", indents + 1, dump_text_VkImageView);  // AET
    dump_text_value<const VkExtent2D>(object.quantizationMapExtent, settings, "VkExtent2D", "quantizationMapExtent", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExtent2D>(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + 1, dump_text_VkExtent2D);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.videoEncodeQuantizationMap, settings, "VkBool32", "videoEncodeQuantizationMap", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const int32_t>(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const int32_t>(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoFormatH265QuantizationMapPropertiesKHR(const VkVideoFormatH265QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeH265CtbSizeFlagsKHR>(object.compatibleCtbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "compatibleCtbSizes", indents + 1, dump_text_VkVideoEncodeH265CtbSizeFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const int32_t>(object.minQIndexDelta, settings, "int32_t", "minQIndexDelta", indents + 1, dump_text_int32_t);  // AET
    dump_text_value<const int32_t>(object.maxQIndexDelta, settings, "int32_t", "maxQIndexDelta", indents + 1, dump_text_int32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoFormatAV1QuantizationMapPropertiesKHR(const VkVideoFormatAV1QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkVideoEncodeAV1SuperblockSizeFlagsKHR>(object.compatibleSuperblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "compatibleSuperblockSizes", indents + 1, dump_text_VkVideoEncodeAV1SuperblockSizeFlagsKHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderRawAccessChains, settings, "VkBool32", "shaderRawAccessChains", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalComputeQueueDeviceCreateInfoNV(const VkExternalComputeQueueDeviceCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.reservedExternalQueues, settings, "uint32_t", "reservedExternalQueues", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalComputeQueueCreateInfoNV(const VkExternalComputeQueueCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkQueue>(object.preferredQueue, settings, "VkQueue", "preferredQueue", indents + 1, dump_text_VkQueue);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkExternalComputeQueueDataParamsNV(const VkExternalComputeQueueDataParamsNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const VkPhysicalDeviceExternalComputeQueuePropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.externalDataSize, settings, "uint32_t", "externalDataSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxExternalQueues, settings, "uint32_t", "maxExternalQueues", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderRelaxedExtendedInstruction, settings, "VkBool32", "shaderRelaxedExtendedInstruction", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.commandBufferInheritance, settings, "VkBool32", "commandBufferInheritance", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance7FeaturesKHR(const VkPhysicalDeviceMaintenance7FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.maintenance7, settings, "VkBool32", "maintenance7", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance7PropertiesKHR(const VkPhysicalDeviceMaintenance7PropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.robustFragmentShadingRateAttachmentAccess, settings, "VkBool32", "robustFragmentShadingRateAttachmentAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.separateDepthStencilAttachmentAccess, settings, "VkBool32", "separateDepthStencilAttachmentAccess", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalUniformBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalStorageBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLayeredApiPropertiesKHR(const VkPhysicalDeviceLayeredApiPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.vendorID, settings, "uint32_t", "vendorID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.deviceID, settings, "uint32_t", "deviceID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPhysicalDeviceLayeredApiKHR>(object.layeredAPI, settings, "VkPhysicalDeviceLayeredApiKHR", "layeredAPI", indents + 1, dump_text_VkPhysicalDeviceLayeredApiKHR);  // AET
    dump_text_value<const char*>(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + 1, dump_text_cstring);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLayeredApiPropertiesListKHR(const VkPhysicalDeviceLayeredApiPropertiesListKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.layeredApiCount, settings, "uint32_t", "layeredApiCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPhysicalDeviceLayeredApiPropertiesKHR>(object.pLayeredApis, object.layeredApiCount, settings, "VkPhysicalDeviceLayeredApiPropertiesKHR*", "VkPhysicalDeviceLayeredApiPropertiesKHR", "pLayeredApis", indents + 1, dump_text_VkPhysicalDeviceLayeredApiPropertiesKHR); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPhysicalDeviceProperties2>(object.properties, settings, "VkPhysicalDeviceProperties2", "properties", indents + 1, dump_text_VkPhysicalDeviceProperties2);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderFloat16VectorAtomics, settings, "VkBool32", "shaderFloat16VectorAtomics", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.shaderReplicatedComposites, settings, "VkBool32", "shaderReplicatedComposites", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.rayTracingValidation, settings, "VkBool32", "rayTracingValidation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.clusterAccelerationStructure, settings, "VkBool32", "clusterAccelerationStructure", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxVerticesPerCluster, settings, "uint32_t", "maxVerticesPerCluster", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTrianglesPerCluster, settings, "uint32_t", "maxTrianglesPerCluster", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterScratchByteAlignment, settings, "uint32_t", "clusterScratchByteAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterByteAlignment, settings, "uint32_t", "clusterByteAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterTemplateByteAlignment, settings, "uint32_t", "clusterTemplateByteAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterBottomLevelByteAlignment, settings, "uint32_t", "clusterBottomLevelByteAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterTemplateBoundsByteAlignment, settings, "uint32_t", "clusterTemplateBoundsByteAlignment", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxClusterGeometryIndex, settings, "uint32_t", "maxClusterGeometryIndex", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkClusterAccelerationStructureClustersBottomLevelInputNV(const VkClusterAccelerationStructureClustersBottomLevelInputNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxTotalClusterCount, settings, "uint32_t", "maxTotalClusterCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxClusterCountPerAccelerationStructure, settings, "uint32_t", "maxClusterCountPerAccelerationStructure", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkClusterAccelerationStructureTriangleClusterInputNV(const VkClusterAccelerationStructureTriangleClusterInputNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkFormat>(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + 1, dump_text_VkFormat);  // AET
    dump_text_value<const uint32_t>(object.maxGeometryIndexValue, settings, "uint32_t", "maxGeometryIndexValue", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxClusterUniqueGeometryCount, settings, "uint32_t", "maxClusterUniqueGeometryCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxClusterTriangleCount, settings, "uint32_t", "maxClusterTriangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxClusterVertexCount, settings, "uint32_t", "maxClusterVertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTotalTriangleCount, settings, "uint32_t", "maxTotalTriangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxTotalVertexCount, settings, "uint32_t", "maxTotalVertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.minPositionTruncateBitCount, settings, "uint32_t", "minPositionTruncateBitCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkClusterAccelerationStructureMoveObjectsInputNV(const VkClusterAccelerationStructureMoveObjectsInputNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkClusterAccelerationStructureTypeNV>(object.type, settings, "VkClusterAccelerationStructureTypeNV", "type", indents + 1, dump_text_VkClusterAccelerationStructureTypeNV);  // AET
    dump_text_value<const VkBool32>(object.noMoveOverlap, settings, "VkBool32", "noMoveOverlap", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkDeviceSize>(object.maxMovedBytes, settings, "VkDeviceSize", "maxMovedBytes", indents + 1, dump_text_VkDeviceSize);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxAccelerationStructureCount, settings, "uint32_t", "maxAccelerationStructureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkBuildAccelerationStructureFlagsKHR>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + 1, dump_text_VkBuildAccelerationStructureFlagsKHR);  // AET
    dump_text_value<const VkClusterAccelerationStructureOpTypeNV>(object.opType, settings, "VkClusterAccelerationStructureOpTypeNV", "opType", indents + 1, dump_text_VkClusterAccelerationStructureOpTypeNV);  // AET
    dump_text_value<const VkClusterAccelerationStructureOpModeNV>(object.opMode, settings, "VkClusterAccelerationStructureOpModeNV", "opMode", indents + 1, dump_text_VkClusterAccelerationStructureOpModeNV);  // AET
    dump_text_value<const VkClusterAccelerationStructureOpInputNV>(object.opInput, settings, "VkClusterAccelerationStructureOpInputNV", "opInput", indents + 1, dump_text_VkClusterAccelerationStructureOpInputNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkClusterAccelerationStructureCommandsInfoNV(const VkClusterAccelerationStructureCommandsInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkClusterAccelerationStructureInputInfoNV>(object.input, settings, "VkClusterAccelerationStructureInputInfoNV", "input", indents + 1, dump_text_VkClusterAccelerationStructureInputInfoNV);  // AET
    dump_text_value<const VkDeviceAddress>(object.dstImplicitData, settings, "VkDeviceAddress", "dstImplicitData", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkStridedDeviceAddressRegionKHR>(object.dstAddressesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstAddressesArray", indents + 1, dump_text_VkStridedDeviceAddressRegionKHR);  // AET
    dump_text_value<const VkStridedDeviceAddressRegionKHR>(object.dstSizesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstSizesArray", indents + 1, dump_text_VkStridedDeviceAddressRegionKHR);  // AET
    dump_text_value<const VkStridedDeviceAddressRegionKHR>(object.srcInfosArray, settings, "VkStridedDeviceAddressRegionKHR", "srcInfosArray", indents + 1, dump_text_VkStridedDeviceAddressRegionKHR);  // AET
    dump_text_value<const VkDeviceAddress>(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkClusterAccelerationStructureAddressResolutionFlagsNV>(object.addressResolutionFlags, settings, "VkClusterAccelerationStructureAddressResolutionFlagsNV", "addressResolutionFlags", indents + 1, dump_text_VkClusterAccelerationStructureAddressResolutionFlagsNV);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkStridedDeviceAddressNV(const VkStridedDeviceAddressNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.startAddress, settings, "VkDeviceAddress", "startAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.strideInBytes, settings, "VkDeviceSize", "strideInBytes", indents + 1, dump_text_VkDeviceSize);  // AET
}
void dump_text_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.geometryIndex, settings, "uint32_t geometryIndex:24", "geometryIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.reserved, settings, "uint32_t reserved:5", "reserved", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.geometryFlags, settings, "uint32_t geometryFlags:3", "geometryFlags", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkClusterAccelerationStructureMoveObjectsInfoNV(const VkClusterAccelerationStructureMoveObjectsInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.srcAccelerationStructure, settings, "VkDeviceAddress", "srcAccelerationStructure", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV(const VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.clusterReferencesCount, settings, "uint32_t", "clusterReferencesCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.clusterReferencesStride, settings, "uint32_t", "clusterReferencesStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.clusterReferences, settings, "VkDeviceAddress", "clusterReferences", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkClusterAccelerationStructureBuildTriangleClusterInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.clusterID, settings, "uint32_t", "clusterID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkClusterAccelerationStructureClusterFlagsNV>(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + 1, dump_text_VkClusterAccelerationStructureClusterFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.triangleCount, settings, "uint32_t triangleCount:9", "triangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vertexCount, settings, "uint32_t vertexCount:9", "vertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.positionTruncateBitCount, settings, "uint32_t positionTruncateBitCount:6", "positionTruncateBitCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.indexType, settings, "uint32_t indexType:4", "indexType", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.opacityMicromapIndexType, settings, "uint32_t opacityMicromapIndexType:4", "opacityMicromapIndexType", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + 1, dump_text_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV);  // AET
    dump_text_value<const uint16_t>(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.clusterID, settings, "uint32_t", "clusterID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkClusterAccelerationStructureClusterFlagsNV>(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + 1, dump_text_VkClusterAccelerationStructureClusterFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.triangleCount, settings, "uint32_t triangleCount:9", "triangleCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.vertexCount, settings, "uint32_t vertexCount:9", "vertexCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.positionTruncateBitCount, settings, "uint32_t positionTruncateBitCount:6", "positionTruncateBitCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.indexType, settings, "uint32_t indexType:4", "indexType", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.opacityMicromapIndexType, settings, "uint32_t opacityMicromapIndexType:4", "opacityMicromapIndexType", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV>(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + 1, dump_text_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV);  // AET
    dump_text_value<const uint16_t>(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const uint16_t>(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + 1, dump_text_uint16_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.instantiationBoundingBoxLimit, settings, "VkDeviceAddress", "instantiationBoundingBoxLimit", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkClusterAccelerationStructureInstantiateClusterInfoNV(const VkClusterAccelerationStructureInstantiateClusterInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.clusterIdOffset, settings, "uint32_t", "clusterIdOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.geometryIndexOffset, settings, "uint32_t geometryIndexOffset:24", "geometryIndexOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.reserved, settings, "uint32_t reserved:8", "reserved", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.clusterTemplateAddress, settings, "VkDeviceAddress", "clusterTemplateAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkStridedDeviceAddressNV>(object.vertexBuffer, settings, "VkStridedDeviceAddressNV", "vertexBuffer", indents + 1, dump_text_VkStridedDeviceAddressNV);  // AET
}
void dump_text_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.allowClusterAccelerationStructure, settings, "VkBool32", "allowClusterAccelerationStructure", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.partitionedAccelerationStructure, settings, "VkBool32", "partitionedAccelerationStructure", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxPartitionCount, settings, "uint32_t", "maxPartitionCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPartitionedAccelerationStructureFlagsNV(const VkPartitionedAccelerationStructureFlagsNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.enablePartitionTranslation, settings, "VkBool32", "enablePartitionTranslation", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBuildPartitionedAccelerationStructureIndirectCommandNV(const VkBuildPartitionedAccelerationStructureIndirectCommandNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkPartitionedAccelerationStructureOpTypeNV>(object.opType, settings, "VkPartitionedAccelerationStructureOpTypeNV", "opType", indents + 1, dump_text_VkPartitionedAccelerationStructureOpTypeNV);  // AET
    dump_text_value<const uint32_t>(object.argCount, settings, "uint32_t", "argCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkStridedDeviceAddressNV>(object.argData, settings, "VkStridedDeviceAddressNV", "argData", indents + 1, dump_text_VkStridedDeviceAddressNV);  // AET
}
void dump_text_VkPartitionedAccelerationStructureWriteInstanceDataNV(const VkPartitionedAccelerationStructureWriteInstanceDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkTransformMatrixKHR>(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + 1, dump_text_VkTransformMatrixKHR);  // AET
    dump_text_array<const float>(object.explicitAABB, 6, settings, "float[6]", "float", "explicitAABB", indents + 1, dump_text_float); // AQA
    dump_text_value<const uint32_t>(object.instanceID, settings, "uint32_t", "instanceID", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceMask, settings, "uint32_t", "instanceMask", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPartitionedAccelerationStructureInstanceFlagsNV>(object.instanceFlags, settings, "VkPartitionedAccelerationStructureInstanceFlagsNV", "instanceFlags", indents + 1, dump_text_VkPartitionedAccelerationStructureInstanceFlagsNV);  // AET
    dump_text_value<const uint32_t>(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkPartitionedAccelerationStructureUpdateInstanceDataNV(const VkPartitionedAccelerationStructureUpdateInstanceDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + 1, dump_text_VkDeviceAddress);  // AET
}
void dump_text_VkPartitionedAccelerationStructureWritePartitionTranslationDataNV(const VkPartitionedAccelerationStructureWritePartitionTranslationDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const float>(object.partitionTranslation, 3, settings, "float[3]", "float", "partitionTranslation", indents + 1, dump_text_float); // AQA
}
void dump_text_VkWriteDescriptorSetPartitionedAccelerationStructureNV(const VkWriteDescriptorSetPartitionedAccelerationStructureNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDeviceAddress>(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkDeviceAddress*", "const VkDeviceAddress", "pAccelerationStructures", indents + 1, dump_text_VkDeviceAddress); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPartitionedAccelerationStructureInstancesInputNV(const VkPartitionedAccelerationStructureInstancesInputNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBuildAccelerationStructureFlagsKHR>(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + 1, dump_text_VkBuildAccelerationStructureFlagsKHR);  // AET
    dump_text_value<const uint32_t>(object.instanceCount, settings, "uint32_t", "instanceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxInstancePerPartitionCount, settings, "uint32_t", "maxInstancePerPartitionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.partitionCount, settings, "uint32_t", "partitionCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxInstanceInGlobalPartitionCount, settings, "uint32_t", "maxInstanceInGlobalPartitionCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkBuildPartitionedAccelerationStructureInfoNV(const VkBuildPartitionedAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPartitionedAccelerationStructureInstancesInputNV>(object.input, settings, "VkPartitionedAccelerationStructureInstancesInputNV", "input", indents + 1, dump_text_VkPartitionedAccelerationStructureInstancesInputNV);  // AET
    dump_text_value<const VkDeviceAddress>(object.srcAccelerationStructureData, settings, "VkDeviceAddress", "srcAccelerationStructureData", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.dstAccelerationStructureData, settings, "VkDeviceAddress", "dstAccelerationStructureData", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.srcInfos, settings, "VkDeviceAddress", "srcInfos", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceAddress>(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + 1, dump_text_VkDeviceAddress);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.dynamicGeneratedPipelineLayout, settings, "VkBool32", "dynamicGeneratedPipelineLayout", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.maxIndirectPipelineCount, settings, "uint32_t", "maxIndirectPipelineCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectShaderObjectCount, settings, "uint32_t", "maxIndirectShaderObjectCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxIndirectCommandsIndirectStride, settings, "uint32_t", "maxIndirectCommandsIndirectStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndirectCommandsInputModeFlagsEXT>(object.supportedIndirectCommandsInputModes, settings, "VkIndirectCommandsInputModeFlagsEXT", "supportedIndirectCommandsInputModes", indents + 1, dump_text_VkIndirectCommandsInputModeFlagsEXT);  // AET
    dump_text_value<const VkShaderStageFlags>(object.supportedIndirectCommandsShaderStages, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkShaderStageFlags>(object.supportedIndirectCommandsShaderStagesPipelineBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesPipelineBinding", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkShaderStageFlags>(object.supportedIndirectCommandsShaderStagesShaderBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesShaderBinding", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkBool32>(object.deviceGeneratedCommandsTransformFeedback, settings, "VkBool32", "deviceGeneratedCommandsTransformFeedback", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.deviceGeneratedCommandsMultiDrawIndirectCount, settings, "VkBool32", "deviceGeneratedCommandsMultiDrawIndirectCount", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeneratedCommandsMemoryRequirementsInfoEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectExecutionSetEXT>(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + 1, dump_text_VkIndirectExecutionSetEXT);  // AET
    dump_text_value<const VkIndirectCommandsLayoutEXT>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + 1, dump_text_VkIndirectCommandsLayoutEXT);  // AET
    dump_text_value<const uint32_t>(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectExecutionSetPipelineInfoEXT(const VkIndirectExecutionSetPipelineInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkPipeline>(object.initialPipeline, settings, "VkPipeline", "initialPipeline", indents + 1, dump_text_VkPipeline);  // AET
    dump_text_value<const uint32_t>(object.maxPipelineCount, settings, "uint32_t", "maxPipelineCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectExecutionSetShaderLayoutInfoEXT(const VkIndirectExecutionSetShaderLayoutInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkDescriptorSetLayout>(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "const VkDescriptorSetLayout", "pSetLayouts", indents + 1, dump_text_VkDescriptorSetLayout); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectExecutionSetShaderInfoEXT(const VkIndirectExecutionSetShaderInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.shaderCount, settings, "uint32_t", "shaderCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkShaderEXT>(object.pInitialShaders, object.shaderCount, settings, "const VkShaderEXT*", "const VkShaderEXT", "pInitialShaders", indents + 1, dump_text_VkShaderEXT); // BQB
    dump_text_array<const VkIndirectExecutionSetShaderLayoutInfoEXT>(object.pSetLayoutInfos, object.shaderCount, settings, "const VkIndirectExecutionSetShaderLayoutInfoEXT*", "const VkIndirectExecutionSetShaderLayoutInfoEXT", "pSetLayoutInfos", indents + 1, dump_text_VkIndirectExecutionSetShaderLayoutInfoEXT); // BQB
    dump_text_value<const uint32_t>(object.maxShaderCount, settings, "uint32_t", "maxShaderCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkPushConstantRange>(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "const VkPushConstantRange", "pPushConstantRanges", indents + 1, dump_text_VkPushConstantRange); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectExecutionSetCreateInfoEXT(const VkIndirectExecutionSetCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectExecutionSetInfoTypeEXT>(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + 1, dump_text_VkIndirectExecutionSetInfoTypeEXT);  // AET
    dump_text_value<const VkIndirectExecutionSetInfoEXT>(object.info, settings, "VkIndirectExecutionSetInfoEXT", "info", indents + 1, dump_text_VkIndirectExecutionSetInfoEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkShaderStageFlags>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const VkIndirectExecutionSetEXT>(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + 1, dump_text_VkIndirectExecutionSetEXT);  // AET
    dump_text_value<const VkIndirectCommandsLayoutEXT>(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + 1, dump_text_VkIndirectCommandsLayoutEXT);  // AET
    dump_text_value<const VkDeviceAddress>(object.indirectAddress, settings, "VkDeviceAddress", "indirectAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.indirectAddressSize, settings, "VkDeviceSize", "indirectAddressSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const VkDeviceAddress>(object.preprocessAddress, settings, "VkDeviceAddress", "preprocessAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const VkDeviceSize>(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + 1, dump_text_VkDeviceSize);  // AET
    dump_text_value<const uint32_t>(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkDeviceAddress>(object.sequenceCountAddress, settings, "VkDeviceAddress", "sequenceCountAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteIndirectExecutionSetPipelineEXT(const VkWriteIndirectExecutionSetPipelineEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectCommandsPushConstantTokenEXT(const VkIndirectCommandsPushConstantTokenEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkPushConstantRange>(object.updateRange, settings, "VkPushConstantRange", "updateRange", indents + 1, dump_text_VkPushConstantRange);  // AET
}
void dump_text_VkIndirectCommandsVertexBufferTokenEXT(const VkIndirectCommandsVertexBufferTokenEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const uint32_t>(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkIndirectCommandsIndexBufferTokenEXT(const VkIndirectCommandsIndexBufferTokenEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkIndirectCommandsInputModeFlagBitsEXT>(object.mode, settings, "VkIndirectCommandsInputModeFlagBitsEXT", "mode", indents + 1, dump_text_VkIndirectCommandsInputModeFlagBitsEXT);  // AET
}
void dump_text_VkIndirectCommandsExecutionSetTokenEXT(const VkIndirectCommandsExecutionSetTokenEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkIndirectExecutionSetInfoTypeEXT>(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + 1, dump_text_VkIndirectExecutionSetInfoTypeEXT);  // AET
    dump_text_value<const VkShaderStageFlags>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
}
void dump_text_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    ApiDumpInstance::current().setIndirectCommandsLayoutToken(object.type);
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectCommandsTokenTypeEXT>(object.type, settings, "VkIndirectCommandsTokenTypeEXT", "type", indents + 1, dump_text_VkIndirectCommandsTokenTypeEXT);  // AET
    dump_text_value<const VkIndirectCommandsTokenDataEXT>(object.data, settings, "VkIndirectCommandsTokenDataEXT", "data", indents + 1, dump_text_VkIndirectCommandsTokenDataEXT);  // AET
    dump_text_value<const uint32_t>(object.offset, settings, "uint32_t", "offset", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkIndirectCommandsLayoutCreateInfoEXT(const VkIndirectCommandsLayoutCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkIndirectCommandsLayoutUsageFlagsEXT>(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsEXT", "flags", indents + 1, dump_text_VkIndirectCommandsLayoutUsageFlagsEXT);  // AET
    dump_text_value<const VkShaderStageFlags>(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + 1, dump_text_VkShaderStageFlags);  // AET
    dump_text_value<const uint32_t>(object.indirectStride, settings, "uint32_t", "indirectStride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkPipelineLayout>(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + 1, dump_text_VkPipelineLayout);  // AET
    dump_text_value<const uint32_t>(object.tokenCount, settings, "uint32_t", "tokenCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkIndirectCommandsLayoutTokenEXT>(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenEXT*", "const VkIndirectCommandsLayoutTokenEXT", "pTokens", indents + 1, dump_text_VkIndirectCommandsLayoutTokenEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkDrawIndirectCountIndirectCommandEXT(const VkDrawIndirectCountIndirectCommandEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.commandCount, settings, "uint32_t", "commandCount", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkBindVertexBufferIndirectCommandEXT(const VkBindVertexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.stride, settings, "uint32_t", "stride", indents + 1, dump_text_uint32_t);  // AET
}
void dump_text_VkBindIndexBufferIndirectCommandEXT(const VkBindIndexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkDeviceAddress>(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + 1, dump_text_VkDeviceAddress);  // AET
    dump_text_value<const uint32_t>(object.size, settings, "uint32_t", "size", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkIndexType>(object.indexType, settings, "VkIndexType", "indexType", indents + 1, dump_text_VkIndexType);  // AET
}
void dump_text_VkGeneratedCommandsPipelineInfoEXT(const VkGeneratedCommandsPipelineInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkPipeline>(object.pipeline, settings, "VkPipeline", "pipeline", indents + 1, dump_text_VkPipeline);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.shaderCount, settings, "uint32_t", "shaderCount", indents + 1, dump_text_uint32_t);  // AET
    dump_text_array<const VkShaderEXT>(object.pShaders, object.shaderCount, settings, "const VkShaderEXT*", "const VkShaderEXT", "pShaders", indents + 1, dump_text_VkShaderEXT); // BQB
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkWriteIndirectExecutionSetShaderEXT(const VkWriteIndirectExecutionSetShaderEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.index, settings, "uint32_t", "index", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkShaderEXT>(object.shader, settings, "VkShaderEXT", "shader", indents + 1, dump_text_VkShaderEXT);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceMaintenance8FeaturesKHR(const VkPhysicalDeviceMaintenance8FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.maintenance8, settings, "VkBool32", "maintenance8", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkAccessFlags3KHR>(object.srcAccessMask3, settings, "VkAccessFlags3KHR", "srcAccessMask3", indents + 1, dump_text_VkAccessFlags3KHR);  // AET
    dump_text_value<const VkAccessFlags3KHR>(object.dstAccessMask3, settings, "VkAccessFlags3KHR", "dstAccessMask3", indents + 1, dump_text_VkAccessFlags3KHR);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.imageAlignmentControl, settings, "VkBool32", "imageAlignmentControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.supportedImageAlignmentMask, settings, "uint32_t", "supportedImageAlignmentMask", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkImageAlignmentControlCreateInfoMESA(const VkImageAlignmentControlCreateInfoMESA& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.maximumRequestedAlignment, settings, "uint32_t", "maximumRequestedAlignment", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceDepthClampControlFeaturesEXT(const VkPhysicalDeviceDepthClampControlFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.depthClampControl, settings, "VkBool32", "depthClampControl", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPipelineViewportDepthClampControlCreateInfoEXT(const VkPipelineViewportDepthClampControlCreateInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDepthClampModeEXT>(object.depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", indents + 1, dump_text_VkDepthClampModeEXT);  // AET
    dump_text_pointer<const VkDepthClampRangeEXT>(object.pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", indents + 1, dump_text_VkDepthClampRangeEXT);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.videoMaintenance2, settings, "VkBool32", "videoMaintenance2", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH264InlineSessionParametersInfoKHR(const VkVideoDecodeH264InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoH264SequenceParameterSet>(object.pStdSPS, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPS", indents + 1, dump_text_StdVideoH264SequenceParameterSet);
    dump_text_pointer<const StdVideoH264PictureParameterSet>(object.pStdPPS, settings, "const StdVideoH264PictureParameterSet*", "pStdPPS", indents + 1, dump_text_StdVideoH264PictureParameterSet);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeH265InlineSessionParametersInfoKHR(const VkVideoDecodeH265InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoH265VideoParameterSet>(object.pStdVPS, settings, "const StdVideoH265VideoParameterSet*", "pStdVPS", indents + 1, dump_text_StdVideoH265VideoParameterSet);
    dump_text_pointer<const StdVideoH265SequenceParameterSet>(object.pStdSPS, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPS", indents + 1, dump_text_StdVideoH265SequenceParameterSet);
    dump_text_pointer<const StdVideoH265PictureParameterSet>(object.pStdPPS, settings, "const StdVideoH265PictureParameterSet*", "pStdPPS", indents + 1, dump_text_StdVideoH265PictureParameterSet);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkVideoDecodeAV1InlineSessionParametersInfoKHR(const VkVideoDecodeAV1InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_pointer<const StdVideoAV1SequenceHeader>(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + 1, dump_text_StdVideoAV1SequenceHeader);
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceHdrVividFeaturesHUAWEI(const VkPhysicalDeviceHdrVividFeaturesHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.hdrVivid, settings, "VkBool32", "hdrVivid", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkHdrVividDynamicMetadataHUAWEI(const VkHdrVividDynamicMetadataHUAWEI& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const size_t>(object.dynamicMetadataSize, settings, "size_t", "dynamicMetadataSize", indents + 1, dump_text_size_t);  // AET
    dump_text_value<const void*>(object.pDynamicMetadata, settings, "const void*", "pDynamicMetadata", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.MGranularity, settings, "uint32_t", "MGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.NGranularity, settings, "uint32_t", "NGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.KGranularity, settings, "uint32_t", "KGranularity", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.AType, settings, "VkComponentTypeKHR", "AType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.BType, settings, "VkComponentTypeKHR", "BType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.CType, settings, "VkComponentTypeKHR", "CType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkComponentTypeKHR>(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + 1, dump_text_VkComponentTypeKHR);  // AET
    dump_text_value<const VkBool32>(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkScopeKHR>(object.scope, settings, "VkScopeKHR", "scope", indents + 1, dump_text_VkScopeKHR);  // AET
    dump_text_value<const uint32_t>(object.workgroupInvocations, settings, "uint32_t", "workgroupInvocations", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.cooperativeMatrixWorkgroupScope, settings, "VkBool32", "cooperativeMatrixWorkgroupScope", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixFlexibleDimensions, settings, "VkBool32", "cooperativeMatrixFlexibleDimensions", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixReductions, settings, "VkBool32", "cooperativeMatrixReductions", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixConversions, settings, "VkBool32", "cooperativeMatrixConversions", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixPerElementOperations, settings, "VkBool32", "cooperativeMatrixPerElementOperations", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixTensorAddressing, settings, "VkBool32", "cooperativeMatrixTensorAddressing", indents + 1, dump_text_VkBool32);  // AET
    dump_text_value<const VkBool32>(object.cooperativeMatrixBlockLoads, settings, "VkBool32", "cooperativeMatrixBlockLoads", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(const VkPhysicalDeviceCooperativeMatrix2PropertiesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeMaxWorkgroupSize", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.cooperativeMatrixFlexibleDimensionsMaxDimension, settings, "uint32_t", "cooperativeMatrixFlexibleDimensionsMaxDimension", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.cooperativeMatrixWorkgroupScopeReservedSharedMemory, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeReservedSharedMemory", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
void dump_text_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.pipelineOpacityMicromap, settings, "VkBool32", "pipelineOpacityMicromap", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkImportMemoryMetalHandleInfoEXT(const VkImportMemoryMetalHandleInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    dump_text_value<const void*>(object.handle, settings, "void*", "handle", indents + 1, dump_text_void);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkMemoryMetalHandlePropertiesEXT(const VkMemoryMetalHandlePropertiesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const uint32_t>(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_VkMemoryGetMetalHandleInfoEXT(const VkMemoryGetMetalHandleInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const VkDeviceMemory>(object.memory, settings, "VkDeviceMemory", "memory", indents + 1, dump_text_VkDeviceMemory);  // AET
    dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + 1, dump_text_VkExternalMemoryHandleTypeFlagBits);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.vertexAttributeRobustness, settings, "VkBool32", "vertexAttributeRobustness", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkSetPresentConfigNV(const VkSetPresentConfigNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    dump_text_value<const uint32_t>(object.numFramesPerBatch, settings, "uint32_t", "numFramesPerBatch", indents + 1, dump_text_uint32_t);  // AET
    dump_text_value<const uint32_t>(object.presentConfigFeedback, settings, "uint32_t", "presentConfigFeedback", indents + 1, dump_text_uint32_t);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkPhysicalDevicePresentMeteringFeaturesNV(const VkPhysicalDevicePresentMeteringFeaturesNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "void*");
    dump_text_value<const VkBool32>(object.presentMetering, settings, "VkBool32", "presentMetering", indents + 1, dump_text_VkBool32);  // AET
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkRenderingEndInfoEXT(const VkRenderingEndInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << ":\n";
    else
        settings.stream() << "address:\n";
    dump_text_value<const VkStructureType>(object.sType, settings, "VkStructureType", "sType", indents + 1, dump_text_VkStructureType);  // AET
    dump_text_pNext_struct_name(object.pNext, settings, indents + 1, "const void*");
    if(object.pNext != nullptr){
        dump_text_pNext_trampoline(object.pNext, settings, indents < 2 ? indents + 1 : indents);
    }
}

//========================== Union Implementations ==========================//

void dump_text_VkClearColorValue(const VkClearColorValue& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_array<const float>(object.float32, 4, settings, "float[4]", "float", "float32", indents + 1, dump_text_float); // GQA
    dump_text_array<const int32_t>(object.int32, 4, settings, "int32_t[4]", "int32_t", "int32", indents + 1, dump_text_int32_t); // GQA
    dump_text_array<const uint32_t>(object.uint32, 4, settings, "uint32_t[4]", "uint32_t", "uint32", indents + 1, dump_text_uint32_t); // GQA
}
void dump_text_VkClearValue(const VkClearValue& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkClearColorValue>(object.color, settings, "VkClearColorValue", "color", indents + 1, dump_text_VkClearColorValue); // LET
    dump_text_value<const VkClearDepthStencilValue>(object.depthStencil, settings, "VkClearDepthStencilValue", "depthStencil", indents + 1, dump_text_VkClearDepthStencilValue); // LET
}
void dump_text_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const int32_t>(object.int32, settings, "int32_t", "int32", indents + 1, dump_text_int32_t); // LET
    dump_text_value<const int64_t>(object.int64, settings, "int64_t", "int64", indents + 1, dump_text_int64_t); // LET
    dump_text_value<const uint32_t>(object.uint32, settings, "uint32_t", "uint32", indents + 1, dump_text_uint32_t); // LET
    dump_text_value<const uint64_t>(object.uint64, settings, "uint64_t", "uint64", indents + 1, dump_text_uint64_t); // LET
    dump_text_value<const float>(object.float32, settings, "float", "float32", indents + 1, dump_text_float); // LET
    dump_text_value<const double>(object.float64, settings, "double", "float64", indents + 1, dump_text_double); // LET
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress); // LET
    dump_text_value<const void*>(object.hostAddress, settings, "const void*", "hostAddress", indents + 1, dump_text_void); // LET
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress); // LET
    dump_text_value<const void*>(object.hostAddress, settings, "void*", "hostAddress", indents + 1, dump_text_void); // LET
}
void dump_text_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkDeviceAddress>(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + 1, dump_text_VkDeviceAddress); // LET
    dump_text_value<const void*>(object.hostAddress, settings, "const void*", "hostAddress", indents + 1, dump_text_void); // LET
}
void dump_text_VkAccelerationStructureGeometryDataKHR(const VkAccelerationStructureGeometryDataKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkAccelerationStructureGeometryTrianglesDataKHR>(object.triangles, settings, "VkAccelerationStructureGeometryTrianglesDataKHR", "triangles", indents + 1, dump_text_VkAccelerationStructureGeometryTrianglesDataKHR); // LET
    dump_text_value<const VkAccelerationStructureGeometryAabbsDataKHR>(object.aabbs, settings, "VkAccelerationStructureGeometryAabbsDataKHR", "aabbs", indents + 1, dump_text_VkAccelerationStructureGeometryAabbsDataKHR); // LET
    dump_text_value<const VkAccelerationStructureGeometryInstancesDataKHR>(object.instances, settings, "VkAccelerationStructureGeometryInstancesDataKHR", "instances", indents + 1, dump_text_VkAccelerationStructureGeometryInstancesDataKHR); // LET
}
void dump_text_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const uint32_t>(object.value32, settings, "uint32_t", "value32", indents + 1, dump_text_uint32_t); // LET
    dump_text_value<const uint64_t>(object.value64, settings, "uint64_t", "value64", indents + 1, dump_text_uint64_t); // LET
    dump_text_value<const float>(object.valueFloat, settings, "float", "valueFloat", indents + 1, dump_text_float); // LET
    dump_text_value<const VkBool32>(object.valueBool, settings, "VkBool32", "valueBool", indents + 1, dump_text_VkBool32); // LET
    dump_text_value<const char*>(object.valueString, settings, "const char*", "valueString", indents + 1, dump_text_cstring); // LET
}
void dump_text_VkPipelineExecutableStatisticValueKHR(const VkPipelineExecutableStatisticValueKHR& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkBool32>(object.b32, settings, "VkBool32", "b32", indents + 1, dump_text_VkBool32); // LET
    dump_text_value<const int64_t>(object.i64, settings, "int64_t", "i64", indents + 1, dump_text_int64_t); // LET
    dump_text_value<const uint64_t>(object.u64, settings, "uint64_t", "u64", indents + 1, dump_text_uint64_t); // LET
    dump_text_value<const double>(object.f64, settings, "double", "f64", indents + 1, dump_text_double); // LET
}
void dump_text_VkDescriptorDataEXT(const VkDescriptorDataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER)
    dump_text_pointer<const VkSampler>(object.pSampler, settings, "const VkSampler*", "pSampler", indents + 1, dump_text_VkSampler);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
    dump_text_pointer<const VkDescriptorImageInfo>(object.pCombinedImageSampler, settings, "const VkDescriptorImageInfo*", "pCombinedImageSampler", indents + 1, dump_text_VkDescriptorImageInfo);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
    dump_text_pointer<const VkDescriptorImageInfo>(object.pInputAttachmentImage, settings, "const VkDescriptorImageInfo*", "pInputAttachmentImage", indents + 1, dump_text_VkDescriptorImageInfo);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
    dump_text_pointer<const VkDescriptorImageInfo>(object.pSampledImage, settings, "const VkDescriptorImageInfo*", "pSampledImage", indents + 1, dump_text_VkDescriptorImageInfo);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
    dump_text_pointer<const VkDescriptorImageInfo>(object.pStorageImage, settings, "const VkDescriptorImageInfo*", "pStorageImage", indents + 1, dump_text_VkDescriptorImageInfo);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
    dump_text_pointer<const VkDescriptorAddressInfoEXT>(object.pUniformTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformTexelBuffer", indents + 1, dump_text_VkDescriptorAddressInfoEXT);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
    dump_text_pointer<const VkDescriptorAddressInfoEXT>(object.pStorageTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageTexelBuffer", indents + 1, dump_text_VkDescriptorAddressInfoEXT);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
    dump_text_pointer<const VkDescriptorAddressInfoEXT>(object.pUniformBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformBuffer", indents + 1, dump_text_VkDescriptorAddressInfoEXT);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
    dump_text_pointer<const VkDescriptorAddressInfoEXT>(object.pStorageBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageBuffer", indents + 1, dump_text_VkDescriptorAddressInfoEXT);
    if(ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR)
    dump_text_value<const VkDeviceAddress>(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + 1, dump_text_VkDeviceAddress); // LET
}
void dump_text_VkAccelerationStructureMotionInstanceDataNV(const VkAccelerationStructureMotionInstanceDataNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_value<const VkAccelerationStructureInstanceKHR>(object.staticInstance, settings, "VkAccelerationStructureInstanceKHR", "staticInstance", indents + 1, dump_text_VkAccelerationStructureInstanceKHR); // LET
    dump_text_value<const VkAccelerationStructureMatrixMotionInstanceNV>(object.matrixMotionInstance, settings, "VkAccelerationStructureMatrixMotionInstanceNV", "matrixMotionInstance", indents + 1, dump_text_VkAccelerationStructureMatrixMotionInstanceNV); // LET
    dump_text_value<const VkAccelerationStructureSRTMotionInstanceNV>(object.srtMotionInstance, settings, "VkAccelerationStructureSRTMotionInstanceNV", "srtMotionInstance", indents + 1, dump_text_VkAccelerationStructureSRTMotionInstanceNV); // LET
}
void dump_text_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    dump_text_pointer<const VkClusterAccelerationStructureClustersBottomLevelInputNV>(object.pClustersBottomLevel, settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV*", "pClustersBottomLevel", indents + 1, dump_text_VkClusterAccelerationStructureClustersBottomLevelInputNV);
    dump_text_pointer<const VkClusterAccelerationStructureTriangleClusterInputNV>(object.pTriangleClusters, settings, "VkClusterAccelerationStructureTriangleClusterInputNV*", "pTriangleClusters", indents + 1, dump_text_VkClusterAccelerationStructureTriangleClusterInputNV);
    dump_text_pointer<const VkClusterAccelerationStructureMoveObjectsInputNV>(object.pMoveObjects, settings, "VkClusterAccelerationStructureMoveObjectsInputNV*", "pMoveObjects", indents + 1, dump_text_VkClusterAccelerationStructureMoveObjectsInputNV);
}
void dump_text_VkIndirectExecutionSetInfoEXT(const VkIndirectExecutionSetInfoEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    if(ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT)
    dump_text_pointer<const VkIndirectExecutionSetPipelineInfoEXT>(object.pPipelineInfo, settings, "const VkIndirectExecutionSetPipelineInfoEXT*", "pPipelineInfo", indents + 1, dump_text_VkIndirectExecutionSetPipelineInfoEXT);
    if(ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT)
    dump_text_pointer<const VkIndirectExecutionSetShaderInfoEXT>(object.pShaderInfo, settings, "const VkIndirectExecutionSetShaderInfoEXT*", "pShaderInfo", indents + 1, dump_text_VkIndirectExecutionSetShaderInfoEXT);
}
void dump_text_VkIndirectCommandsTokenDataEXT(const VkIndirectCommandsTokenDataEXT& object, const ApiDumpSettings& settings, int indents)
{
    if(settings.showAddress())
        settings.stream() << &object << " (Union):\n";
    else
        settings.stream() << "address (Union):\n";
    if(ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT)
    dump_text_pointer<const VkIndirectCommandsPushConstantTokenEXT>(object.pPushConstant, settings, "const VkIndirectCommandsPushConstantTokenEXT*", "pPushConstant", indents + 1, dump_text_VkIndirectCommandsPushConstantTokenEXT);
    if(ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT)
    dump_text_pointer<const VkIndirectCommandsVertexBufferTokenEXT>(object.pVertexBuffer, settings, "const VkIndirectCommandsVertexBufferTokenEXT*", "pVertexBuffer", indents + 1, dump_text_VkIndirectCommandsVertexBufferTokenEXT);
    if(ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT)
    dump_text_pointer<const VkIndirectCommandsIndexBufferTokenEXT>(object.pIndexBuffer, settings, "const VkIndirectCommandsIndexBufferTokenEXT*", "pIndexBuffer", indents + 1, dump_text_VkIndirectCommandsIndexBufferTokenEXT);
    if(ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT)
    dump_text_pointer<const VkIndirectCommandsExecutionSetTokenEXT>(object.pExecutionSet, settings, "const VkIndirectCommandsExecutionSetTokenEXT*", "pExecutionSet", indents + 1, dump_text_VkIndirectCommandsExecutionSetTokenEXT);
}

//======================== pNext Chain Implementation =======================//

void dump_text_pNext_struct_name(const void* object, const ApiDumpSettings& settings, int indents, const char* pnext_type)
{
    if (object == nullptr) {
        dump_text_value<const void*>(object, settings, pnext_type, "pNext", indents, dump_text_void);
        return;
    }

    settings.formatNameType(indents, "pNext", pnext_type);
    switch(reinterpret_cast<const VkBaseInStructure*>(object)->sType) {
        case 44:
            settings.stream() << "VkBufferMemoryBarrier\n";
            break;
        case 45:
            settings.stream() << "VkImageMemoryBarrier\n";
            break;
        case 46:
            settings.stream() << "VkMemoryBarrier\n";
            break;
        case 0:
            settings.stream() << "VkApplicationInfo\n";
            break;
        case 1:
            settings.stream() << "VkInstanceCreateInfo\n";
            break;
        case 2:
            settings.stream() << "VkDeviceQueueCreateInfo\n";
            break;
        case 3:
            settings.stream() << "VkDeviceCreateInfo\n";
            break;
        case 4:
            settings.stream() << "VkSubmitInfo\n";
            break;
        case 6:
            settings.stream() << "VkMappedMemoryRange\n";
            break;
        case 5:
            settings.stream() << "VkMemoryAllocateInfo\n";
            break;
        case 7:
            settings.stream() << "VkBindSparseInfo\n";
            break;
        case 8:
            settings.stream() << "VkFenceCreateInfo\n";
            break;
        case 9:
            settings.stream() << "VkSemaphoreCreateInfo\n";
            break;
        case 10:
            settings.stream() << "VkEventCreateInfo\n";
            break;
        case 11:
            settings.stream() << "VkQueryPoolCreateInfo\n";
            break;
        case 12:
            settings.stream() << "VkBufferCreateInfo\n";
            break;
        case 13:
            settings.stream() << "VkBufferViewCreateInfo\n";
            break;
        case 14:
            settings.stream() << "VkImageCreateInfo\n";
            break;
        case 15:
            settings.stream() << "VkImageViewCreateInfo\n";
            break;
        case 16:
            settings.stream() << "VkShaderModuleCreateInfo\n";
            break;
        case 17:
            settings.stream() << "VkPipelineCacheCreateInfo\n";
            break;
        case 18:
            settings.stream() << "VkPipelineShaderStageCreateInfo\n";
            break;
        case 29:
            settings.stream() << "VkComputePipelineCreateInfo\n";
            break;
        case 19:
            settings.stream() << "VkPipelineVertexInputStateCreateInfo\n";
            break;
        case 20:
            settings.stream() << "VkPipelineInputAssemblyStateCreateInfo\n";
            break;
        case 21:
            settings.stream() << "VkPipelineTessellationStateCreateInfo\n";
            break;
        case 22:
            settings.stream() << "VkPipelineViewportStateCreateInfo\n";
            break;
        case 23:
            settings.stream() << "VkPipelineRasterizationStateCreateInfo\n";
            break;
        case 24:
            settings.stream() << "VkPipelineMultisampleStateCreateInfo\n";
            break;
        case 25:
            settings.stream() << "VkPipelineDepthStencilStateCreateInfo\n";
            break;
        case 26:
            settings.stream() << "VkPipelineColorBlendStateCreateInfo\n";
            break;
        case 27:
            settings.stream() << "VkPipelineDynamicStateCreateInfo\n";
            break;
        case 28:
            settings.stream() << "VkGraphicsPipelineCreateInfo\n";
            break;
        case 30:
            settings.stream() << "VkPipelineLayoutCreateInfo\n";
            break;
        case 31:
            settings.stream() << "VkSamplerCreateInfo\n";
            break;
        case 36:
            settings.stream() << "VkCopyDescriptorSet\n";
            break;
        case 33:
            settings.stream() << "VkDescriptorPoolCreateInfo\n";
            break;
        case 34:
            settings.stream() << "VkDescriptorSetAllocateInfo\n";
            break;
        case 32:
            settings.stream() << "VkDescriptorSetLayoutCreateInfo\n";
            break;
        case 35:
            settings.stream() << "VkWriteDescriptorSet\n";
            break;
        case 37:
            settings.stream() << "VkFramebufferCreateInfo\n";
            break;
        case 38:
            settings.stream() << "VkRenderPassCreateInfo\n";
            break;
        case 39:
            settings.stream() << "VkCommandPoolCreateInfo\n";
            break;
        case 40:
            settings.stream() << "VkCommandBufferAllocateInfo\n";
            break;
        case 41:
            settings.stream() << "VkCommandBufferInheritanceInfo\n";
            break;
        case 42:
            settings.stream() << "VkCommandBufferBeginInfo\n";
            break;
        case 43:
            settings.stream() << "VkRenderPassBeginInfo\n";
            break;
        case 1000094000:
            settings.stream() << "VkPhysicalDeviceSubgroupProperties\n";
            break;
        case 1000157000:
            settings.stream() << "VkBindBufferMemoryInfo\n";
            break;
        case 1000157001:
            settings.stream() << "VkBindImageMemoryInfo\n";
            break;
        case 1000083000:
            settings.stream() << "VkPhysicalDevice16BitStorageFeatures\n";
            break;
        case 1000127000:
            settings.stream() << "VkMemoryDedicatedRequirements\n";
            break;
        case 1000127001:
            settings.stream() << "VkMemoryDedicatedAllocateInfo\n";
            break;
        case 1000060000:
            settings.stream() << "VkMemoryAllocateFlagsInfo\n";
            break;
        case 1000060003:
            settings.stream() << "VkDeviceGroupRenderPassBeginInfo\n";
            break;
        case 1000060004:
            settings.stream() << "VkDeviceGroupCommandBufferBeginInfo\n";
            break;
        case 1000060005:
            settings.stream() << "VkDeviceGroupSubmitInfo\n";
            break;
        case 1000060006:
            settings.stream() << "VkDeviceGroupBindSparseInfo\n";
            break;
        case 1000060013:
            settings.stream() << "VkBindBufferMemoryDeviceGroupInfo\n";
            break;
        case 1000060014:
            settings.stream() << "VkBindImageMemoryDeviceGroupInfo\n";
            break;
        case 1000070000:
            settings.stream() << "VkPhysicalDeviceGroupProperties\n";
            break;
        case 1000070001:
            settings.stream() << "VkDeviceGroupDeviceCreateInfo\n";
            break;
        case 1000146000:
            settings.stream() << "VkBufferMemoryRequirementsInfo2\n";
            break;
        case 1000146001:
            settings.stream() << "VkImageMemoryRequirementsInfo2\n";
            break;
        case 1000146002:
            settings.stream() << "VkImageSparseMemoryRequirementsInfo2\n";
            break;
        case 1000146003:
            settings.stream() << "VkMemoryRequirements2\n";
            break;
        case 1000146004:
            settings.stream() << "VkSparseImageMemoryRequirements2\n";
            break;
        case 1000059000:
            settings.stream() << "VkPhysicalDeviceFeatures2\n";
            break;
        case 1000059001:
            settings.stream() << "VkPhysicalDeviceProperties2\n";
            break;
        case 1000059002:
            settings.stream() << "VkFormatProperties2\n";
            break;
        case 1000059003:
            settings.stream() << "VkImageFormatProperties2\n";
            break;
        case 1000059004:
            settings.stream() << "VkPhysicalDeviceImageFormatInfo2\n";
            break;
        case 1000059005:
            settings.stream() << "VkQueueFamilyProperties2\n";
            break;
        case 1000059006:
            settings.stream() << "VkPhysicalDeviceMemoryProperties2\n";
            break;
        case 1000059007:
            settings.stream() << "VkSparseImageFormatProperties2\n";
            break;
        case 1000059008:
            settings.stream() << "VkPhysicalDeviceSparseImageFormatInfo2\n";
            break;
        case 1000117000:
            settings.stream() << "VkPhysicalDevicePointClippingProperties\n";
            break;
        case 1000117001:
            settings.stream() << "VkRenderPassInputAttachmentAspectCreateInfo\n";
            break;
        case 1000117002:
            settings.stream() << "VkImageViewUsageCreateInfo\n";
            break;
        case 1000117003:
            settings.stream() << "VkPipelineTessellationDomainOriginStateCreateInfo\n";
            break;
        case 1000053000:
            settings.stream() << "VkRenderPassMultiviewCreateInfo\n";
            break;
        case 1000053001:
            settings.stream() << "VkPhysicalDeviceMultiviewFeatures\n";
            break;
        case 1000053002:
            settings.stream() << "VkPhysicalDeviceMultiviewProperties\n";
            break;
        case 1000120000:
            settings.stream() << "VkPhysicalDeviceVariablePointersFeatures\n";
            break;
        case 1000145001:
            settings.stream() << "VkPhysicalDeviceProtectedMemoryFeatures\n";
            break;
        case 1000145002:
            settings.stream() << "VkPhysicalDeviceProtectedMemoryProperties\n";
            break;
        case 1000145003:
            settings.stream() << "VkDeviceQueueInfo2\n";
            break;
        case 1000145000:
            settings.stream() << "VkProtectedSubmitInfo\n";
            break;
        case 1000156000:
            settings.stream() << "VkSamplerYcbcrConversionCreateInfo\n";
            break;
        case 1000156001:
            settings.stream() << "VkSamplerYcbcrConversionInfo\n";
            break;
        case 1000156002:
            settings.stream() << "VkBindImagePlaneMemoryInfo\n";
            break;
        case 1000156003:
            settings.stream() << "VkImagePlaneMemoryRequirementsInfo\n";
            break;
        case 1000156004:
            settings.stream() << "VkPhysicalDeviceSamplerYcbcrConversionFeatures\n";
            break;
        case 1000156005:
            settings.stream() << "VkSamplerYcbcrConversionImageFormatProperties\n";
            break;
        case 1000085000:
            settings.stream() << "VkDescriptorUpdateTemplateCreateInfo\n";
            break;
        case 1000071000:
            settings.stream() << "VkPhysicalDeviceExternalImageFormatInfo\n";
            break;
        case 1000071001:
            settings.stream() << "VkExternalImageFormatProperties\n";
            break;
        case 1000071002:
            settings.stream() << "VkPhysicalDeviceExternalBufferInfo\n";
            break;
        case 1000071003:
            settings.stream() << "VkExternalBufferProperties\n";
            break;
        case 1000071004:
            settings.stream() << "VkPhysicalDeviceIDProperties\n";
            break;
        case 1000072001:
            settings.stream() << "VkExternalMemoryImageCreateInfo\n";
            break;
        case 1000072000:
            settings.stream() << "VkExternalMemoryBufferCreateInfo\n";
            break;
        case 1000072002:
            settings.stream() << "VkExportMemoryAllocateInfo\n";
            break;
        case 1000112000:
            settings.stream() << "VkPhysicalDeviceExternalFenceInfo\n";
            break;
        case 1000112001:
            settings.stream() << "VkExternalFenceProperties\n";
            break;
        case 1000113000:
            settings.stream() << "VkExportFenceCreateInfo\n";
            break;
        case 1000077000:
            settings.stream() << "VkExportSemaphoreCreateInfo\n";
            break;
        case 1000076000:
            settings.stream() << "VkPhysicalDeviceExternalSemaphoreInfo\n";
            break;
        case 1000076001:
            settings.stream() << "VkExternalSemaphoreProperties\n";
            break;
        case 1000168000:
            settings.stream() << "VkPhysicalDeviceMaintenance3Properties\n";
            break;
        case 1000168001:
            settings.stream() << "VkDescriptorSetLayoutSupport\n";
            break;
        case 1000063000:
            settings.stream() << "VkPhysicalDeviceShaderDrawParametersFeatures\n";
            break;
        case 49:
            settings.stream() << "VkPhysicalDeviceVulkan11Features\n";
            break;
        case 50:
            settings.stream() << "VkPhysicalDeviceVulkan11Properties\n";
            break;
        case 51:
            settings.stream() << "VkPhysicalDeviceVulkan12Features\n";
            break;
        case 52:
            settings.stream() << "VkPhysicalDeviceVulkan12Properties\n";
            break;
        case 1000147000:
            settings.stream() << "VkImageFormatListCreateInfo\n";
            break;
        case 1000109000:
            settings.stream() << "VkAttachmentDescription2\n";
            break;
        case 1000109001:
            settings.stream() << "VkAttachmentReference2\n";
            break;
        case 1000109002:
            settings.stream() << "VkSubpassDescription2\n";
            break;
        case 1000109003:
            settings.stream() << "VkSubpassDependency2\n";
            break;
        case 1000109004:
            settings.stream() << "VkRenderPassCreateInfo2\n";
            break;
        case 1000109005:
            settings.stream() << "VkSubpassBeginInfo\n";
            break;
        case 1000109006:
            settings.stream() << "VkSubpassEndInfo\n";
            break;
        case 1000177000:
            settings.stream() << "VkPhysicalDevice8BitStorageFeatures\n";
            break;
        case 1000196000:
            settings.stream() << "VkPhysicalDeviceDriverProperties\n";
            break;
        case 1000180000:
            settings.stream() << "VkPhysicalDeviceShaderAtomicInt64Features\n";
            break;
        case 1000082000:
            settings.stream() << "VkPhysicalDeviceShaderFloat16Int8Features\n";
            break;
        case 1000197000:
            settings.stream() << "VkPhysicalDeviceFloatControlsProperties\n";
            break;
        case 1000161000:
            settings.stream() << "VkDescriptorSetLayoutBindingFlagsCreateInfo\n";
            break;
        case 1000161001:
            settings.stream() << "VkPhysicalDeviceDescriptorIndexingFeatures\n";
            break;
        case 1000161002:
            settings.stream() << "VkPhysicalDeviceDescriptorIndexingProperties\n";
            break;
        case 1000161003:
            settings.stream() << "VkDescriptorSetVariableDescriptorCountAllocateInfo\n";
            break;
        case 1000161004:
            settings.stream() << "VkDescriptorSetVariableDescriptorCountLayoutSupport\n";
            break;
        case 1000199001:
            settings.stream() << "VkSubpassDescriptionDepthStencilResolve\n";
            break;
        case 1000199000:
            settings.stream() << "VkPhysicalDeviceDepthStencilResolveProperties\n";
            break;
        case 1000221000:
            settings.stream() << "VkPhysicalDeviceScalarBlockLayoutFeatures\n";
            break;
        case 1000246000:
            settings.stream() << "VkImageStencilUsageCreateInfo\n";
            break;
        case 1000130001:
            settings.stream() << "VkSamplerReductionModeCreateInfo\n";
            break;
        case 1000130000:
            settings.stream() << "VkPhysicalDeviceSamplerFilterMinmaxProperties\n";
            break;
        case 1000211000:
            settings.stream() << "VkPhysicalDeviceVulkanMemoryModelFeatures\n";
            break;
        case 1000108000:
            settings.stream() << "VkPhysicalDeviceImagelessFramebufferFeatures\n";
            break;
        case 1000108002:
            settings.stream() << "VkFramebufferAttachmentImageInfo\n";
            break;
        case 1000108001:
            settings.stream() << "VkFramebufferAttachmentsCreateInfo\n";
            break;
        case 1000108003:
            settings.stream() << "VkRenderPassAttachmentBeginInfo\n";
            break;
        case 1000253000:
            settings.stream() << "VkPhysicalDeviceUniformBufferStandardLayoutFeatures\n";
            break;
        case 1000175000:
            settings.stream() << "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures\n";
            break;
        case 1000241000:
            settings.stream() << "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures\n";
            break;
        case 1000241001:
            settings.stream() << "VkAttachmentReferenceStencilLayout\n";
            break;
        case 1000241002:
            settings.stream() << "VkAttachmentDescriptionStencilLayout\n";
            break;
        case 1000261000:
            settings.stream() << "VkPhysicalDeviceHostQueryResetFeatures\n";
            break;
        case 1000207000:
            settings.stream() << "VkPhysicalDeviceTimelineSemaphoreFeatures\n";
            break;
        case 1000207001:
            settings.stream() << "VkPhysicalDeviceTimelineSemaphoreProperties\n";
            break;
        case 1000207002:
            settings.stream() << "VkSemaphoreTypeCreateInfo\n";
            break;
        case 1000207003:
            settings.stream() << "VkTimelineSemaphoreSubmitInfo\n";
            break;
        case 1000207004:
            settings.stream() << "VkSemaphoreWaitInfo\n";
            break;
        case 1000207005:
            settings.stream() << "VkSemaphoreSignalInfo\n";
            break;
        case 1000257000:
            settings.stream() << "VkPhysicalDeviceBufferDeviceAddressFeatures\n";
            break;
        case 1000244001:
            settings.stream() << "VkBufferDeviceAddressInfo\n";
            break;
        case 1000257002:
            settings.stream() << "VkBufferOpaqueCaptureAddressCreateInfo\n";
            break;
        case 1000257003:
            settings.stream() << "VkMemoryOpaqueCaptureAddressAllocateInfo\n";
            break;
        case 1000257004:
            settings.stream() << "VkDeviceMemoryOpaqueCaptureAddressInfo\n";
            break;
        case 53:
            settings.stream() << "VkPhysicalDeviceVulkan13Features\n";
            break;
        case 54:
            settings.stream() << "VkPhysicalDeviceVulkan13Properties\n";
            break;
        case 1000192000:
            settings.stream() << "VkPipelineCreationFeedbackCreateInfo\n";
            break;
        case 1000215000:
            settings.stream() << "VkPhysicalDeviceShaderTerminateInvocationFeatures\n";
            break;
        case 1000245000:
            settings.stream() << "VkPhysicalDeviceToolProperties\n";
            break;
        case 1000276000:
            settings.stream() << "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures\n";
            break;
        case 1000295000:
            settings.stream() << "VkPhysicalDevicePrivateDataFeatures\n";
            break;
        case 1000295001:
            settings.stream() << "VkDevicePrivateDataCreateInfo\n";
            break;
        case 1000295002:
            settings.stream() << "VkPrivateDataSlotCreateInfo\n";
            break;
        case 1000297000:
            settings.stream() << "VkPhysicalDevicePipelineCreationCacheControlFeatures\n";
            break;
        case 1000314000:
            settings.stream() << "VkMemoryBarrier2\n";
            break;
        case 1000314001:
            settings.stream() << "VkBufferMemoryBarrier2\n";
            break;
        case 1000314002:
            settings.stream() << "VkImageMemoryBarrier2\n";
            break;
        case 1000314003:
            settings.stream() << "VkDependencyInfo\n";
            break;
        case 1000314005:
            settings.stream() << "VkSemaphoreSubmitInfo\n";
            break;
        case 1000314006:
            settings.stream() << "VkCommandBufferSubmitInfo\n";
            break;
        case 1000314004:
            settings.stream() << "VkSubmitInfo2\n";
            break;
        case 1000314007:
            settings.stream() << "VkPhysicalDeviceSynchronization2Features\n";
            break;
        case 1000325000:
            settings.stream() << "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures\n";
            break;
        case 1000335000:
            settings.stream() << "VkPhysicalDeviceImageRobustnessFeatures\n";
            break;
        case 1000337006:
            settings.stream() << "VkBufferCopy2\n";
            break;
        case 1000337000:
            settings.stream() << "VkCopyBufferInfo2\n";
            break;
        case 1000337007:
            settings.stream() << "VkImageCopy2\n";
            break;
        case 1000337001:
            settings.stream() << "VkCopyImageInfo2\n";
            break;
        case 1000337009:
            settings.stream() << "VkBufferImageCopy2\n";
            break;
        case 1000337002:
            settings.stream() << "VkCopyBufferToImageInfo2\n";
            break;
        case 1000337003:
            settings.stream() << "VkCopyImageToBufferInfo2\n";
            break;
        case 1000337008:
            settings.stream() << "VkImageBlit2\n";
            break;
        case 1000337004:
            settings.stream() << "VkBlitImageInfo2\n";
            break;
        case 1000337010:
            settings.stream() << "VkImageResolve2\n";
            break;
        case 1000337005:
            settings.stream() << "VkResolveImageInfo2\n";
            break;
        case 1000225002:
            settings.stream() << "VkPhysicalDeviceSubgroupSizeControlFeatures\n";
            break;
        case 1000225000:
            settings.stream() << "VkPhysicalDeviceSubgroupSizeControlProperties\n";
            break;
        case 1000225001:
            settings.stream() << "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo\n";
            break;
        case 1000138000:
            settings.stream() << "VkPhysicalDeviceInlineUniformBlockFeatures\n";
            break;
        case 1000138001:
            settings.stream() << "VkPhysicalDeviceInlineUniformBlockProperties\n";
            break;
        case 1000138002:
            settings.stream() << "VkWriteDescriptorSetInlineUniformBlock\n";
            break;
        case 1000138003:
            settings.stream() << "VkDescriptorPoolInlineUniformBlockCreateInfo\n";
            break;
        case 1000066000:
            settings.stream() << "VkPhysicalDeviceTextureCompressionASTCHDRFeatures\n";
            break;
        case 1000044001:
            settings.stream() << "VkRenderingAttachmentInfo\n";
            break;
        case 1000044000:
            settings.stream() << "VkRenderingInfo\n";
            break;
        case 1000044002:
            settings.stream() << "VkPipelineRenderingCreateInfo\n";
            break;
        case 1000044003:
            settings.stream() << "VkPhysicalDeviceDynamicRenderingFeatures\n";
            break;
        case 1000044004:
            settings.stream() << "VkCommandBufferInheritanceRenderingInfo\n";
            break;
        case 1000280000:
            settings.stream() << "VkPhysicalDeviceShaderIntegerDotProductFeatures\n";
            break;
        case 1000280001:
            settings.stream() << "VkPhysicalDeviceShaderIntegerDotProductProperties\n";
            break;
        case 1000281001:
            settings.stream() << "VkPhysicalDeviceTexelBufferAlignmentProperties\n";
            break;
        case 1000360000:
            settings.stream() << "VkFormatProperties3\n";
            break;
        case 1000413000:
            settings.stream() << "VkPhysicalDeviceMaintenance4Features\n";
            break;
        case 1000413001:
            settings.stream() << "VkPhysicalDeviceMaintenance4Properties\n";
            break;
        case 1000413002:
            settings.stream() << "VkDeviceBufferMemoryRequirements\n";
            break;
        case 1000413003:
            settings.stream() << "VkDeviceImageMemoryRequirements\n";
            break;
        case 55:
            settings.stream() << "VkPhysicalDeviceVulkan14Features\n";
            break;
        case 56:
            settings.stream() << "VkPhysicalDeviceVulkan14Properties\n";
            break;
        case 1000174000:
            settings.stream() << "VkDeviceQueueGlobalPriorityCreateInfo\n";
            break;
        case 1000388000:
            settings.stream() << "VkPhysicalDeviceGlobalPriorityQueryFeatures\n";
            break;
        case 1000388001:
            settings.stream() << "VkQueueFamilyGlobalPriorityProperties\n";
            break;
        case 1000416000:
            settings.stream() << "VkPhysicalDeviceShaderSubgroupRotateFeatures\n";
            break;
        case 1000528000:
            settings.stream() << "VkPhysicalDeviceShaderFloatControls2Features\n";
            break;
        case 1000544000:
            settings.stream() << "VkPhysicalDeviceShaderExpectAssumeFeatures\n";
            break;
        case 1000259000:
            settings.stream() << "VkPhysicalDeviceLineRasterizationFeatures\n";
            break;
        case 1000259002:
            settings.stream() << "VkPhysicalDeviceLineRasterizationProperties\n";
            break;
        case 1000259001:
            settings.stream() << "VkPipelineRasterizationLineStateCreateInfo\n";
            break;
        case 1000525000:
            settings.stream() << "VkPhysicalDeviceVertexAttributeDivisorProperties\n";
            break;
        case 1000190001:
            settings.stream() << "VkPipelineVertexInputDivisorStateCreateInfo\n";
            break;
        case 1000190002:
            settings.stream() << "VkPhysicalDeviceVertexAttributeDivisorFeatures\n";
            break;
        case 1000265000:
            settings.stream() << "VkPhysicalDeviceIndexTypeUint8Features\n";
            break;
        case 1000271000:
            settings.stream() << "VkMemoryMapInfo\n";
            break;
        case 1000271001:
            settings.stream() << "VkMemoryUnmapInfo\n";
            break;
        case 1000470000:
            settings.stream() << "VkPhysicalDeviceMaintenance5Features\n";
            break;
        case 1000470001:
            settings.stream() << "VkPhysicalDeviceMaintenance5Properties\n";
            break;
        case 1000470003:
            settings.stream() << "VkRenderingAreaInfo\n";
            break;
        case 1000338003:
            settings.stream() << "VkImageSubresource2\n";
            break;
        case 1000470004:
            settings.stream() << "VkDeviceImageSubresourceInfo\n";
            break;
        case 1000338002:
            settings.stream() << "VkSubresourceLayout2\n";
            break;
        case 1000470005:
            settings.stream() << "VkPipelineCreateFlags2CreateInfo\n";
            break;
        case 1000470006:
            settings.stream() << "VkBufferUsageFlags2CreateInfo\n";
            break;
        case 1000080000:
            settings.stream() << "VkPhysicalDevicePushDescriptorProperties\n";
            break;
        case 1000232000:
            settings.stream() << "VkPhysicalDeviceDynamicRenderingLocalReadFeatures\n";
            break;
        case 1000232001:
            settings.stream() << "VkRenderingAttachmentLocationInfo\n";
            break;
        case 1000232002:
            settings.stream() << "VkRenderingInputAttachmentIndexInfo\n";
            break;
        case 1000545000:
            settings.stream() << "VkPhysicalDeviceMaintenance6Features\n";
            break;
        case 1000545001:
            settings.stream() << "VkPhysicalDeviceMaintenance6Properties\n";
            break;
        case 1000545002:
            settings.stream() << "VkBindMemoryStatus\n";
            break;
        case 1000545003:
            settings.stream() << "VkBindDescriptorSetsInfo\n";
            break;
        case 1000545004:
            settings.stream() << "VkPushConstantsInfo\n";
            break;
        case 1000545005:
            settings.stream() << "VkPushDescriptorSetInfo\n";
            break;
        case 1000545006:
            settings.stream() << "VkPushDescriptorSetWithTemplateInfo\n";
            break;
        case 1000466000:
            settings.stream() << "VkPhysicalDevicePipelineProtectedAccessFeatures\n";
            break;
        case 1000068001:
            settings.stream() << "VkPhysicalDevicePipelineRobustnessFeatures\n";
            break;
        case 1000068002:
            settings.stream() << "VkPhysicalDevicePipelineRobustnessProperties\n";
            break;
        case 1000068000:
            settings.stream() << "VkPipelineRobustnessCreateInfo\n";
            break;
        case 1000270000:
            settings.stream() << "VkPhysicalDeviceHostImageCopyFeatures\n";
            break;
        case 1000270001:
            settings.stream() << "VkPhysicalDeviceHostImageCopyProperties\n";
            break;
        case 1000270002:
            settings.stream() << "VkMemoryToImageCopy\n";
            break;
        case 1000270003:
            settings.stream() << "VkImageToMemoryCopy\n";
            break;
        case 1000270005:
            settings.stream() << "VkCopyMemoryToImageInfo\n";
            break;
        case 1000270004:
            settings.stream() << "VkCopyImageToMemoryInfo\n";
            break;
        case 1000270007:
            settings.stream() << "VkCopyImageToImageInfo\n";
            break;
        case 1000270006:
            settings.stream() << "VkHostImageLayoutTransitionInfo\n";
            break;
        case 1000270008:
            settings.stream() << "VkSubresourceHostMemcpySize\n";
            break;
        case 1000270009:
            settings.stream() << "VkHostImageCopyDevicePerformanceQuery\n";
            break;
        case 1000001000:
            settings.stream() << "VkSwapchainCreateInfoKHR\n";
            break;
        case 1000001001:
            settings.stream() << "VkPresentInfoKHR\n";
            break;
        case 1000060008:
            settings.stream() << "VkImageSwapchainCreateInfoKHR\n";
            break;
        case 1000060009:
            settings.stream() << "VkBindImageMemorySwapchainInfoKHR\n";
            break;
        case 1000060010:
            settings.stream() << "VkAcquireNextImageInfoKHR\n";
            break;
        case 1000060007:
            settings.stream() << "VkDeviceGroupPresentCapabilitiesKHR\n";
            break;
        case 1000060011:
            settings.stream() << "VkDeviceGroupPresentInfoKHR\n";
            break;
        case 1000060012:
            settings.stream() << "VkDeviceGroupSwapchainCreateInfoKHR\n";
            break;
        case 1000002000:
            settings.stream() << "VkDisplayModeCreateInfoKHR\n";
            break;
        case 1000002001:
            settings.stream() << "VkDisplaySurfaceCreateInfoKHR\n";
            break;
        case 1000003000:
            settings.stream() << "VkDisplayPresentInfoKHR\n";
            break;
#if defined(VK_USE_PLATFORM_XLIB_KHR)
        case 1000004000:
            settings.stream() << "VkXlibSurfaceCreateInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
        case 1000005000:
            settings.stream() << "VkXcbSurfaceCreateInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
        case 1000006000:
            settings.stream() << "VkWaylandSurfaceCreateInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000008000:
            settings.stream() << "VkAndroidSurfaceCreateInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000009000:
            settings.stream() << "VkWin32SurfaceCreateInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000011000:
            settings.stream() << "VkDebugReportCallbackCreateInfoEXT\n";
            break;
        case 1000018000:
            settings.stream() << "VkPipelineRasterizationStateRasterizationOrderAMD\n";
            break;
        case 1000022000:
            settings.stream() << "VkDebugMarkerObjectNameInfoEXT\n";
            break;
        case 1000022001:
            settings.stream() << "VkDebugMarkerObjectTagInfoEXT\n";
            break;
        case 1000022002:
            settings.stream() << "VkDebugMarkerMarkerInfoEXT\n";
            break;
        case 1000023016:
            settings.stream() << "VkQueueFamilyQueryResultStatusPropertiesKHR\n";
            break;
        case 1000023012:
            settings.stream() << "VkQueueFamilyVideoPropertiesKHR\n";
            break;
        case 1000023000:
            settings.stream() << "VkVideoProfileInfoKHR\n";
            break;
        case 1000023013:
            settings.stream() << "VkVideoProfileListInfoKHR\n";
            break;
        case 1000023001:
            settings.stream() << "VkVideoCapabilitiesKHR\n";
            break;
        case 1000023014:
            settings.stream() << "VkPhysicalDeviceVideoFormatInfoKHR\n";
            break;
        case 1000023015:
            settings.stream() << "VkVideoFormatPropertiesKHR\n";
            break;
        case 1000023002:
            settings.stream() << "VkVideoPictureResourceInfoKHR\n";
            break;
        case 1000023011:
            settings.stream() << "VkVideoReferenceSlotInfoKHR\n";
            break;
        case 1000023003:
            settings.stream() << "VkVideoSessionMemoryRequirementsKHR\n";
            break;
        case 1000023004:
            settings.stream() << "VkBindVideoSessionMemoryInfoKHR\n";
            break;
        case 1000023005:
            settings.stream() << "VkVideoSessionCreateInfoKHR\n";
            break;
        case 1000023006:
            settings.stream() << "VkVideoSessionParametersCreateInfoKHR\n";
            break;
        case 1000023007:
            settings.stream() << "VkVideoSessionParametersUpdateInfoKHR\n";
            break;
        case 1000023008:
            settings.stream() << "VkVideoBeginCodingInfoKHR\n";
            break;
        case 1000023009:
            settings.stream() << "VkVideoEndCodingInfoKHR\n";
            break;
        case 1000023010:
            settings.stream() << "VkVideoCodingControlInfoKHR\n";
            break;
        case 1000024001:
            settings.stream() << "VkVideoDecodeCapabilitiesKHR\n";
            break;
        case 1000024002:
            settings.stream() << "VkVideoDecodeUsageInfoKHR\n";
            break;
        case 1000024000:
            settings.stream() << "VkVideoDecodeInfoKHR\n";
            break;
        case 1000026000:
            settings.stream() << "VkDedicatedAllocationImageCreateInfoNV\n";
            break;
        case 1000026001:
            settings.stream() << "VkDedicatedAllocationBufferCreateInfoNV\n";
            break;
        case 1000026002:
            settings.stream() << "VkDedicatedAllocationMemoryAllocateInfoNV\n";
            break;
        case 1000028000:
            settings.stream() << "VkPhysicalDeviceTransformFeedbackFeaturesEXT\n";
            break;
        case 1000028001:
            settings.stream() << "VkPhysicalDeviceTransformFeedbackPropertiesEXT\n";
            break;
        case 1000028002:
            settings.stream() << "VkPipelineRasterizationStateStreamCreateInfoEXT\n";
            break;
        case 1000029000:
            settings.stream() << "VkCuModuleCreateInfoNVX\n";
            break;
        case 1000029004:
            settings.stream() << "VkCuModuleTexturingModeCreateInfoNVX\n";
            break;
        case 1000029001:
            settings.stream() << "VkCuFunctionCreateInfoNVX\n";
            break;
        case 1000029002:
            settings.stream() << "VkCuLaunchInfoNVX\n";
            break;
        case 1000030000:
            settings.stream() << "VkImageViewHandleInfoNVX\n";
            break;
        case 1000030001:
            settings.stream() << "VkImageViewAddressPropertiesNVX\n";
            break;
        case 1000038000:
            settings.stream() << "VkVideoEncodeH264CapabilitiesKHR\n";
            break;
        case 1000038011:
            settings.stream() << "VkVideoEncodeH264QualityLevelPropertiesKHR\n";
            break;
        case 1000038010:
            settings.stream() << "VkVideoEncodeH264SessionCreateInfoKHR\n";
            break;
        case 1000038002:
            settings.stream() << "VkVideoEncodeH264SessionParametersAddInfoKHR\n";
            break;
        case 1000038001:
            settings.stream() << "VkVideoEncodeH264SessionParametersCreateInfoKHR\n";
            break;
        case 1000038012:
            settings.stream() << "VkVideoEncodeH264SessionParametersGetInfoKHR\n";
            break;
        case 1000038013:
            settings.stream() << "VkVideoEncodeH264SessionParametersFeedbackInfoKHR\n";
            break;
        case 1000038005:
            settings.stream() << "VkVideoEncodeH264NaluSliceInfoKHR\n";
            break;
        case 1000038003:
            settings.stream() << "VkVideoEncodeH264PictureInfoKHR\n";
            break;
        case 1000038004:
            settings.stream() << "VkVideoEncodeH264DpbSlotInfoKHR\n";
            break;
        case 1000038007:
            settings.stream() << "VkVideoEncodeH264ProfileInfoKHR\n";
            break;
        case 1000038008:
            settings.stream() << "VkVideoEncodeH264RateControlInfoKHR\n";
            break;
        case 1000038009:
            settings.stream() << "VkVideoEncodeH264RateControlLayerInfoKHR\n";
            break;
        case 1000038006:
            settings.stream() << "VkVideoEncodeH264GopRemainingFrameInfoKHR\n";
            break;
        case 1000039000:
            settings.stream() << "VkVideoEncodeH265CapabilitiesKHR\n";
            break;
        case 1000039011:
            settings.stream() << "VkVideoEncodeH265SessionCreateInfoKHR\n";
            break;
        case 1000039012:
            settings.stream() << "VkVideoEncodeH265QualityLevelPropertiesKHR\n";
            break;
        case 1000039002:
            settings.stream() << "VkVideoEncodeH265SessionParametersAddInfoKHR\n";
            break;
        case 1000039001:
            settings.stream() << "VkVideoEncodeH265SessionParametersCreateInfoKHR\n";
            break;
        case 1000039013:
            settings.stream() << "VkVideoEncodeH265SessionParametersGetInfoKHR\n";
            break;
        case 1000039014:
            settings.stream() << "VkVideoEncodeH265SessionParametersFeedbackInfoKHR\n";
            break;
        case 1000039005:
            settings.stream() << "VkVideoEncodeH265NaluSliceSegmentInfoKHR\n";
            break;
        case 1000039003:
            settings.stream() << "VkVideoEncodeH265PictureInfoKHR\n";
            break;
        case 1000039004:
            settings.stream() << "VkVideoEncodeH265DpbSlotInfoKHR\n";
            break;
        case 1000039007:
            settings.stream() << "VkVideoEncodeH265ProfileInfoKHR\n";
            break;
        case 1000039009:
            settings.stream() << "VkVideoEncodeH265RateControlInfoKHR\n";
            break;
        case 1000039010:
            settings.stream() << "VkVideoEncodeH265RateControlLayerInfoKHR\n";
            break;
        case 1000039006:
            settings.stream() << "VkVideoEncodeH265GopRemainingFrameInfoKHR\n";
            break;
        case 1000040003:
            settings.stream() << "VkVideoDecodeH264ProfileInfoKHR\n";
            break;
        case 1000040000:
            settings.stream() << "VkVideoDecodeH264CapabilitiesKHR\n";
            break;
        case 1000040005:
            settings.stream() << "VkVideoDecodeH264SessionParametersAddInfoKHR\n";
            break;
        case 1000040004:
            settings.stream() << "VkVideoDecodeH264SessionParametersCreateInfoKHR\n";
            break;
        case 1000040001:
            settings.stream() << "VkVideoDecodeH264PictureInfoKHR\n";
            break;
        case 1000040006:
            settings.stream() << "VkVideoDecodeH264DpbSlotInfoKHR\n";
            break;
        case 1000041000:
            settings.stream() << "VkTextureLODGatherFormatPropertiesAMD\n";
            break;
#if defined(VK_USE_PLATFORM_GGP)
        case 1000049000:
            settings.stream() << "VkStreamDescriptorSurfaceCreateInfoGGP\n";
            break;
#endif // VK_USE_PLATFORM_GGP
        case 1000050000:
            settings.stream() << "VkPhysicalDeviceCornerSampledImageFeaturesNV\n";
            break;
        case 1000056000:
            settings.stream() << "VkExternalMemoryImageCreateInfoNV\n";
            break;
        case 1000056001:
            settings.stream() << "VkExportMemoryAllocateInfoNV\n";
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000057000:
            settings.stream() << "VkImportMemoryWin32HandleInfoNV\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000057001:
            settings.stream() << "VkExportMemoryWin32HandleInfoNV\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000058000:
            settings.stream() << "VkWin32KeyedMutexAcquireReleaseInfoNV\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000061000:
            settings.stream() << "VkValidationFlagsEXT\n";
            break;
#if defined(VK_USE_PLATFORM_VI_NN)
        case 1000062000:
            settings.stream() << "VkViSurfaceCreateInfoNN\n";
            break;
#endif // VK_USE_PLATFORM_VI_NN
        case 1000067000:
            settings.stream() << "VkImageViewASTCDecodeModeEXT\n";
            break;
        case 1000067001:
            settings.stream() << "VkPhysicalDeviceASTCDecodeFeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000073000:
            settings.stream() << "VkImportMemoryWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000073001:
            settings.stream() << "VkExportMemoryWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000073002:
            settings.stream() << "VkMemoryWin32HandlePropertiesKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000073003:
            settings.stream() << "VkMemoryGetWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000074000:
            settings.stream() << "VkImportMemoryFdInfoKHR\n";
            break;
        case 1000074001:
            settings.stream() << "VkMemoryFdPropertiesKHR\n";
            break;
        case 1000074002:
            settings.stream() << "VkMemoryGetFdInfoKHR\n";
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000075000:
            settings.stream() << "VkWin32KeyedMutexAcquireReleaseInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000078000:
            settings.stream() << "VkImportSemaphoreWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000078001:
            settings.stream() << "VkExportSemaphoreWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000078002:
            settings.stream() << "VkD3D12FenceSubmitInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000078003:
            settings.stream() << "VkSemaphoreGetWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000079000:
            settings.stream() << "VkImportSemaphoreFdInfoKHR\n";
            break;
        case 1000079001:
            settings.stream() << "VkSemaphoreGetFdInfoKHR\n";
            break;
        case 1000081002:
            settings.stream() << "VkConditionalRenderingBeginInfoEXT\n";
            break;
        case 1000081001:
            settings.stream() << "VkPhysicalDeviceConditionalRenderingFeaturesEXT\n";
            break;
        case 1000081000:
            settings.stream() << "VkCommandBufferInheritanceConditionalRenderingInfoEXT\n";
            break;
        case 1000084000:
            settings.stream() << "VkPresentRegionsKHR\n";
            break;
        case 1000087000:
            settings.stream() << "VkPipelineViewportWScalingStateCreateInfoNV\n";
            break;
        case 1000090000:
            settings.stream() << "VkSurfaceCapabilities2EXT\n";
            break;
        case 1000091000:
            settings.stream() << "VkDisplayPowerInfoEXT\n";
            break;
        case 1000091001:
            settings.stream() << "VkDeviceEventInfoEXT\n";
            break;
        case 1000091002:
            settings.stream() << "VkDisplayEventInfoEXT\n";
            break;
        case 1000091003:
            settings.stream() << "VkSwapchainCounterCreateInfoEXT\n";
            break;
        case 1000092000:
            settings.stream() << "VkPresentTimesInfoGOOGLE\n";
            break;
        case 1000097000:
            settings.stream() << "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX\n";
            break;
        case 1000044009:
            settings.stream() << "VkMultiviewPerViewAttributesInfoNVX\n";
            break;
        case 1000098000:
            settings.stream() << "VkPipelineViewportSwizzleStateCreateInfoNV\n";
            break;
        case 1000099000:
            settings.stream() << "VkPhysicalDeviceDiscardRectanglePropertiesEXT\n";
            break;
        case 1000099001:
            settings.stream() << "VkPipelineDiscardRectangleStateCreateInfoEXT\n";
            break;
        case 1000101000:
            settings.stream() << "VkPhysicalDeviceConservativeRasterizationPropertiesEXT\n";
            break;
        case 1000101001:
            settings.stream() << "VkPipelineRasterizationConservativeStateCreateInfoEXT\n";
            break;
        case 1000102000:
            settings.stream() << "VkPhysicalDeviceDepthClipEnableFeaturesEXT\n";
            break;
        case 1000102001:
            settings.stream() << "VkPipelineRasterizationDepthClipStateCreateInfoEXT\n";
            break;
        case 1000105000:
            settings.stream() << "VkHdrMetadataEXT\n";
            break;
        case 1000110000:
            settings.stream() << "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG\n";
            break;
        case 1000111000:
            settings.stream() << "VkSharedPresentSurfaceCapabilitiesKHR\n";
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000114000:
            settings.stream() << "VkImportFenceWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000114001:
            settings.stream() << "VkExportFenceWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000114002:
            settings.stream() << "VkFenceGetWin32HandleInfoKHR\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000115000:
            settings.stream() << "VkImportFenceFdInfoKHR\n";
            break;
        case 1000115001:
            settings.stream() << "VkFenceGetFdInfoKHR\n";
            break;
        case 1000116000:
            settings.stream() << "VkPhysicalDevicePerformanceQueryFeaturesKHR\n";
            break;
        case 1000116001:
            settings.stream() << "VkPhysicalDevicePerformanceQueryPropertiesKHR\n";
            break;
        case 1000116005:
            settings.stream() << "VkPerformanceCounterKHR\n";
            break;
        case 1000116006:
            settings.stream() << "VkPerformanceCounterDescriptionKHR\n";
            break;
        case 1000116002:
            settings.stream() << "VkQueryPoolPerformanceCreateInfoKHR\n";
            break;
        case 1000116004:
            settings.stream() << "VkAcquireProfilingLockInfoKHR\n";
            break;
        case 1000116003:
            settings.stream() << "VkPerformanceQuerySubmitInfoKHR\n";
            break;
        case 1000119000:
            settings.stream() << "VkPhysicalDeviceSurfaceInfo2KHR\n";
            break;
        case 1000119001:
            settings.stream() << "VkSurfaceCapabilities2KHR\n";
            break;
        case 1000119002:
            settings.stream() << "VkSurfaceFormat2KHR\n";
            break;
        case 1000121000:
            settings.stream() << "VkDisplayProperties2KHR\n";
            break;
        case 1000121001:
            settings.stream() << "VkDisplayPlaneProperties2KHR\n";
            break;
        case 1000121002:
            settings.stream() << "VkDisplayModeProperties2KHR\n";
            break;
        case 1000121003:
            settings.stream() << "VkDisplayPlaneInfo2KHR\n";
            break;
        case 1000121004:
            settings.stream() << "VkDisplayPlaneCapabilities2KHR\n";
            break;
#if defined(VK_USE_PLATFORM_IOS_MVK)
        case 1000122000:
            settings.stream() << "VkIOSSurfaceCreateInfoMVK\n";
            break;
#endif // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
        case 1000123000:
            settings.stream() << "VkMacOSSurfaceCreateInfoMVK\n";
            break;
#endif // VK_USE_PLATFORM_MACOS_MVK
        case 1000128002:
            settings.stream() << "VkDebugUtilsLabelEXT\n";
            break;
        case 1000128000:
            settings.stream() << "VkDebugUtilsObjectNameInfoEXT\n";
            break;
        case 1000128003:
            settings.stream() << "VkDebugUtilsMessengerCallbackDataEXT\n";
            break;
        case 1000128004:
            settings.stream() << "VkDebugUtilsMessengerCreateInfoEXT\n";
            break;
        case 1000128001:
            settings.stream() << "VkDebugUtilsObjectTagInfoEXT\n";
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129000:
            settings.stream() << "VkAndroidHardwareBufferUsageANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129001:
            settings.stream() << "VkAndroidHardwareBufferPropertiesANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129002:
            settings.stream() << "VkAndroidHardwareBufferFormatPropertiesANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129003:
            settings.stream() << "VkImportAndroidHardwareBufferInfoANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129004:
            settings.stream() << "VkMemoryGetAndroidHardwareBufferInfoANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129005:
            settings.stream() << "VkExternalFormatANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000129006:
            settings.stream() << "VkAndroidHardwareBufferFormatProperties2ANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000134000:
            settings.stream() << "VkPhysicalDeviceShaderEnqueueFeaturesAMDX\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000134001:
            settings.stream() << "VkPhysicalDeviceShaderEnqueuePropertiesAMDX\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000134002:
            settings.stream() << "VkExecutionGraphPipelineScratchSizeAMDX\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000290000:
            settings.stream() << "VkPipelineLibraryCreateInfoKHR\n";
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000134003:
            settings.stream() << "VkExecutionGraphPipelineCreateInfoAMDX\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000134004:
            settings.stream() << "VkPipelineShaderStageNodeCreateInfoAMDX\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000044008:
            settings.stream() << "VkAttachmentSampleCountInfoAMD\n";
            break;
        case 1000141000:
            settings.stream() << "VkPhysicalDeviceShaderBfloat16FeaturesKHR\n";
            break;
        case 1000143000:
            settings.stream() << "VkSampleLocationsInfoEXT\n";
            break;
        case 1000143001:
            settings.stream() << "VkRenderPassSampleLocationsBeginInfoEXT\n";
            break;
        case 1000143002:
            settings.stream() << "VkPipelineSampleLocationsStateCreateInfoEXT\n";
            break;
        case 1000143003:
            settings.stream() << "VkPhysicalDeviceSampleLocationsPropertiesEXT\n";
            break;
        case 1000143004:
            settings.stream() << "VkMultisamplePropertiesEXT\n";
            break;
        case 1000148000:
            settings.stream() << "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT\n";
            break;
        case 1000148001:
            settings.stream() << "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT\n";
            break;
        case 1000148002:
            settings.stream() << "VkPipelineColorBlendAdvancedStateCreateInfoEXT\n";
            break;
        case 1000149000:
            settings.stream() << "VkPipelineCoverageToColorStateCreateInfoNV\n";
            break;
        case 1000150005:
            settings.stream() << "VkAccelerationStructureGeometryTrianglesDataKHR\n";
            break;
        case 1000150003:
            settings.stream() << "VkAccelerationStructureGeometryAabbsDataKHR\n";
            break;
        case 1000150004:
            settings.stream() << "VkAccelerationStructureGeometryInstancesDataKHR\n";
            break;
        case 1000150006:
            settings.stream() << "VkAccelerationStructureGeometryKHR\n";
            break;
        case 1000150000:
            settings.stream() << "VkAccelerationStructureBuildGeometryInfoKHR\n";
            break;
        case 1000150017:
            settings.stream() << "VkAccelerationStructureCreateInfoKHR\n";
            break;
        case 1000150007:
            settings.stream() << "VkWriteDescriptorSetAccelerationStructureKHR\n";
            break;
        case 1000150013:
            settings.stream() << "VkPhysicalDeviceAccelerationStructureFeaturesKHR\n";
            break;
        case 1000150014:
            settings.stream() << "VkPhysicalDeviceAccelerationStructurePropertiesKHR\n";
            break;
        case 1000150002:
            settings.stream() << "VkAccelerationStructureDeviceAddressInfoKHR\n";
            break;
        case 1000150009:
            settings.stream() << "VkAccelerationStructureVersionInfoKHR\n";
            break;
        case 1000150011:
            settings.stream() << "VkCopyAccelerationStructureToMemoryInfoKHR\n";
            break;
        case 1000150012:
            settings.stream() << "VkCopyMemoryToAccelerationStructureInfoKHR\n";
            break;
        case 1000150010:
            settings.stream() << "VkCopyAccelerationStructureInfoKHR\n";
            break;
        case 1000150020:
            settings.stream() << "VkAccelerationStructureBuildSizesInfoKHR\n";
            break;
        case 1000152000:
            settings.stream() << "VkPipelineCoverageModulationStateCreateInfoNV\n";
            break;
        case 1000154001:
            settings.stream() << "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV\n";
            break;
        case 1000154000:
            settings.stream() << "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV\n";
            break;
        case 1000158000:
            settings.stream() << "VkDrmFormatModifierPropertiesListEXT\n";
            break;
        case 1000158002:
            settings.stream() << "VkPhysicalDeviceImageDrmFormatModifierInfoEXT\n";
            break;
        case 1000158003:
            settings.stream() << "VkImageDrmFormatModifierListCreateInfoEXT\n";
            break;
        case 1000158004:
            settings.stream() << "VkImageDrmFormatModifierExplicitCreateInfoEXT\n";
            break;
        case 1000158005:
            settings.stream() << "VkImageDrmFormatModifierPropertiesEXT\n";
            break;
        case 1000158006:
            settings.stream() << "VkDrmFormatModifierPropertiesList2EXT\n";
            break;
        case 1000160000:
            settings.stream() << "VkValidationCacheCreateInfoEXT\n";
            break;
        case 1000160001:
            settings.stream() << "VkShaderModuleValidationCacheCreateInfoEXT\n";
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000163000:
            settings.stream() << "VkPhysicalDevicePortabilitySubsetFeaturesKHR\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000163001:
            settings.stream() << "VkPhysicalDevicePortabilitySubsetPropertiesKHR\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000164000:
            settings.stream() << "VkPipelineViewportShadingRateImageStateCreateInfoNV\n";
            break;
        case 1000164001:
            settings.stream() << "VkPhysicalDeviceShadingRateImageFeaturesNV\n";
            break;
        case 1000164002:
            settings.stream() << "VkPhysicalDeviceShadingRateImagePropertiesNV\n";
            break;
        case 1000164005:
            settings.stream() << "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV\n";
            break;
        case 1000165011:
            settings.stream() << "VkRayTracingShaderGroupCreateInfoNV\n";
            break;
        case 1000165000:
            settings.stream() << "VkRayTracingPipelineCreateInfoNV\n";
            break;
        case 1000165004:
            settings.stream() << "VkGeometryTrianglesNV\n";
            break;
        case 1000165005:
            settings.stream() << "VkGeometryAABBNV\n";
            break;
        case 1000165003:
            settings.stream() << "VkGeometryNV\n";
            break;
        case 1000165012:
            settings.stream() << "VkAccelerationStructureInfoNV\n";
            break;
        case 1000165001:
            settings.stream() << "VkAccelerationStructureCreateInfoNV\n";
            break;
        case 1000165006:
            settings.stream() << "VkBindAccelerationStructureMemoryInfoNV\n";
            break;
        case 1000165007:
            settings.stream() << "VkWriteDescriptorSetAccelerationStructureNV\n";
            break;
        case 1000165008:
            settings.stream() << "VkAccelerationStructureMemoryRequirementsInfoNV\n";
            break;
        case 1000165009:
            settings.stream() << "VkPhysicalDeviceRayTracingPropertiesNV\n";
            break;
        case 1000166000:
            settings.stream() << "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV\n";
            break;
        case 1000166001:
            settings.stream() << "VkPipelineRepresentativeFragmentTestStateCreateInfoNV\n";
            break;
        case 1000170000:
            settings.stream() << "VkPhysicalDeviceImageViewImageFormatInfoEXT\n";
            break;
        case 1000170001:
            settings.stream() << "VkFilterCubicImageViewImageFormatPropertiesEXT\n";
            break;
        case 1000178000:
            settings.stream() << "VkImportMemoryHostPointerInfoEXT\n";
            break;
        case 1000178001:
            settings.stream() << "VkMemoryHostPointerPropertiesEXT\n";
            break;
        case 1000178002:
            settings.stream() << "VkPhysicalDeviceExternalMemoryHostPropertiesEXT\n";
            break;
        case 1000181000:
            settings.stream() << "VkPhysicalDeviceShaderClockFeaturesKHR\n";
            break;
        case 1000183000:
            settings.stream() << "VkPipelineCompilerControlCreateInfoAMD\n";
            break;
        case 1000184000:
            settings.stream() << "VkCalibratedTimestampInfoKHR\n";
            break;
        case 1000185000:
            settings.stream() << "VkPhysicalDeviceShaderCorePropertiesAMD\n";
            break;
        case 1000187003:
            settings.stream() << "VkVideoDecodeH265ProfileInfoKHR\n";
            break;
        case 1000187000:
            settings.stream() << "VkVideoDecodeH265CapabilitiesKHR\n";
            break;
        case 1000187002:
            settings.stream() << "VkVideoDecodeH265SessionParametersAddInfoKHR\n";
            break;
        case 1000187001:
            settings.stream() << "VkVideoDecodeH265SessionParametersCreateInfoKHR\n";
            break;
        case 1000187004:
            settings.stream() << "VkVideoDecodeH265PictureInfoKHR\n";
            break;
        case 1000187005:
            settings.stream() << "VkVideoDecodeH265DpbSlotInfoKHR\n";
            break;
        case 1000189000:
            settings.stream() << "VkDeviceMemoryOverallocationCreateInfoAMD\n";
            break;
        case 1000190000:
            settings.stream() << "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_GGP)
        case 1000191000:
            settings.stream() << "VkPresentFrameTokenGGP\n";
            break;
#endif // VK_USE_PLATFORM_GGP
        case 1000201000:
            settings.stream() << "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR\n";
            break;
        case 1000202000:
            settings.stream() << "VkPhysicalDeviceMeshShaderFeaturesNV\n";
            break;
        case 1000202001:
            settings.stream() << "VkPhysicalDeviceMeshShaderPropertiesNV\n";
            break;
        case 1000203000:
            settings.stream() << "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR\n";
            break;
        case 1000204000:
            settings.stream() << "VkPhysicalDeviceShaderImageFootprintFeaturesNV\n";
            break;
        case 1000205000:
            settings.stream() << "VkPipelineViewportExclusiveScissorStateCreateInfoNV\n";
            break;
        case 1000205002:
            settings.stream() << "VkPhysicalDeviceExclusiveScissorFeaturesNV\n";
            break;
        case 1000206001:
            settings.stream() << "VkQueueFamilyCheckpointPropertiesNV\n";
            break;
        case 1000206000:
            settings.stream() << "VkCheckpointDataNV\n";
            break;
        case 1000314008:
            settings.stream() << "VkQueueFamilyCheckpointProperties2NV\n";
            break;
        case 1000314009:
            settings.stream() << "VkCheckpointData2NV\n";
            break;
        case 1000209000:
            settings.stream() << "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL\n";
            break;
        case 1000210001:
            settings.stream() << "VkInitializePerformanceApiInfoINTEL\n";
            break;
        case 1000210000:
            settings.stream() << "VkQueryPoolPerformanceQueryCreateInfoINTEL\n";
            break;
        case 1000210002:
            settings.stream() << "VkPerformanceMarkerInfoINTEL\n";
            break;
        case 1000210003:
            settings.stream() << "VkPerformanceStreamMarkerInfoINTEL\n";
            break;
        case 1000210004:
            settings.stream() << "VkPerformanceOverrideInfoINTEL\n";
            break;
        case 1000210005:
            settings.stream() << "VkPerformanceConfigurationAcquireInfoINTEL\n";
            break;
        case 1000212000:
            settings.stream() << "VkPhysicalDevicePCIBusInfoPropertiesEXT\n";
            break;
        case 1000213000:
            settings.stream() << "VkDisplayNativeHdrSurfaceCapabilitiesAMD\n";
            break;
        case 1000213001:
            settings.stream() << "VkSwapchainDisplayNativeHdrCreateInfoAMD\n";
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000214000:
            settings.stream() << "VkImagePipeSurfaceCreateInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000217000:
            settings.stream() << "VkMetalSurfaceCreateInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
        case 1000218000:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMapFeaturesEXT\n";
            break;
        case 1000218001:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMapPropertiesEXT\n";
            break;
        case 1000218002:
            settings.stream() << "VkRenderPassFragmentDensityMapCreateInfoEXT\n";
            break;
        case 1000044007:
            settings.stream() << "VkRenderingFragmentDensityMapAttachmentInfoEXT\n";
            break;
        case 1000226000:
            settings.stream() << "VkFragmentShadingRateAttachmentInfoKHR\n";
            break;
        case 1000226001:
            settings.stream() << "VkPipelineFragmentShadingRateStateCreateInfoKHR\n";
            break;
        case 1000226003:
            settings.stream() << "VkPhysicalDeviceFragmentShadingRateFeaturesKHR\n";
            break;
        case 1000226002:
            settings.stream() << "VkPhysicalDeviceFragmentShadingRatePropertiesKHR\n";
            break;
        case 1000226004:
            settings.stream() << "VkPhysicalDeviceFragmentShadingRateKHR\n";
            break;
        case 1000044006:
            settings.stream() << "VkRenderingFragmentShadingRateAttachmentInfoKHR\n";
            break;
        case 1000227000:
            settings.stream() << "VkPhysicalDeviceShaderCoreProperties2AMD\n";
            break;
        case 1000229000:
            settings.stream() << "VkPhysicalDeviceCoherentMemoryFeaturesAMD\n";
            break;
        case 1000234000:
            settings.stream() << "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT\n";
            break;
        case 1000235000:
            settings.stream() << "VkPhysicalDeviceShaderQuadControlFeaturesKHR\n";
            break;
        case 1000237000:
            settings.stream() << "VkPhysicalDeviceMemoryBudgetPropertiesEXT\n";
            break;
        case 1000238000:
            settings.stream() << "VkPhysicalDeviceMemoryPriorityFeaturesEXT\n";
            break;
        case 1000238001:
            settings.stream() << "VkMemoryPriorityAllocateInfoEXT\n";
            break;
        case 1000239000:
            settings.stream() << "VkSurfaceProtectedCapabilitiesKHR\n";
            break;
        case 1000240000:
            settings.stream() << "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV\n";
            break;
        case 1000244000:
            settings.stream() << "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT\n";
            break;
        case 1000244002:
            settings.stream() << "VkBufferDeviceAddressCreateInfoEXT\n";
            break;
        case 1000247000:
            settings.stream() << "VkValidationFeaturesEXT\n";
            break;
        case 1000248000:
            settings.stream() << "VkPhysicalDevicePresentWaitFeaturesKHR\n";
            break;
        case 1000249001:
            settings.stream() << "VkCooperativeMatrixPropertiesNV\n";
            break;
        case 1000249000:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrixFeaturesNV\n";
            break;
        case 1000249002:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrixPropertiesNV\n";
            break;
        case 1000250000:
            settings.stream() << "VkPhysicalDeviceCoverageReductionModeFeaturesNV\n";
            break;
        case 1000250001:
            settings.stream() << "VkPipelineCoverageReductionStateCreateInfoNV\n";
            break;
        case 1000250002:
            settings.stream() << "VkFramebufferMixedSamplesCombinationNV\n";
            break;
        case 1000251000:
            settings.stream() << "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT\n";
            break;
        case 1000252000:
            settings.stream() << "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT\n";
            break;
        case 1000254000:
            settings.stream() << "VkPhysicalDeviceProvokingVertexFeaturesEXT\n";
            break;
        case 1000254002:
            settings.stream() << "VkPhysicalDeviceProvokingVertexPropertiesEXT\n";
            break;
        case 1000254001:
            settings.stream() << "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT\n";
            break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000255000:
            settings.stream() << "VkSurfaceFullScreenExclusiveInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000255002:
            settings.stream() << "VkSurfaceCapabilitiesFullScreenExclusiveEXT\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
        case 1000255001:
            settings.stream() << "VkSurfaceFullScreenExclusiveWin32InfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_WIN32_KHR
        case 1000256000:
            settings.stream() << "VkHeadlessSurfaceCreateInfoEXT\n";
            break;
        case 1000260000:
            settings.stream() << "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT\n";
            break;
        case 1000267000:
            settings.stream() << "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT\n";
            break;
        case 1000269000:
            settings.stream() << "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR\n";
            break;
        case 1000269001:
            settings.stream() << "VkPipelineInfoKHR\n";
            break;
        case 1000269002:
            settings.stream() << "VkPipelineExecutablePropertiesKHR\n";
            break;
        case 1000269003:
            settings.stream() << "VkPipelineExecutableInfoKHR\n";
            break;
        case 1000269004:
            settings.stream() << "VkPipelineExecutableStatisticKHR\n";
            break;
        case 1000269005:
            settings.stream() << "VkPipelineExecutableInternalRepresentationKHR\n";
            break;
        case 1000272000:
            settings.stream() << "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT\n";
            break;
        case 1000272001:
            settings.stream() << "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT\n";
            break;
        case 1000272002:
            settings.stream() << "VkMemoryMapPlacedInfoEXT\n";
            break;
        case 1000273000:
            settings.stream() << "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT\n";
            break;
        case 1000274000:
            settings.stream() << "VkSurfacePresentModeEXT\n";
            break;
        case 1000274001:
            settings.stream() << "VkSurfacePresentScalingCapabilitiesEXT\n";
            break;
        case 1000274002:
            settings.stream() << "VkSurfacePresentModeCompatibilityEXT\n";
            break;
        case 1000275000:
            settings.stream() << "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT\n";
            break;
        case 1000275001:
            settings.stream() << "VkSwapchainPresentFenceInfoEXT\n";
            break;
        case 1000275002:
            settings.stream() << "VkSwapchainPresentModesCreateInfoEXT\n";
            break;
        case 1000275003:
            settings.stream() << "VkSwapchainPresentModeInfoEXT\n";
            break;
        case 1000275004:
            settings.stream() << "VkSwapchainPresentScalingCreateInfoEXT\n";
            break;
        case 1000275005:
            settings.stream() << "VkReleaseSwapchainImagesInfoEXT\n";
            break;
        case 1000277000:
            settings.stream() << "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV\n";
            break;
        case 1000277007:
            settings.stream() << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV\n";
            break;
        case 1000277001:
            settings.stream() << "VkGraphicsShaderGroupCreateInfoNV\n";
            break;
        case 1000277002:
            settings.stream() << "VkGraphicsPipelineShaderGroupsCreateInfoNV\n";
            break;
        case 1000277003:
            settings.stream() << "VkIndirectCommandsLayoutTokenNV\n";
            break;
        case 1000277004:
            settings.stream() << "VkIndirectCommandsLayoutCreateInfoNV\n";
            break;
        case 1000277005:
            settings.stream() << "VkGeneratedCommandsInfoNV\n";
            break;
        case 1000277006:
            settings.stream() << "VkGeneratedCommandsMemoryRequirementsInfoNV\n";
            break;
        case 1000278000:
            settings.stream() << "VkPhysicalDeviceInheritedViewportScissorFeaturesNV\n";
            break;
        case 1000278001:
            settings.stream() << "VkCommandBufferInheritanceViewportScissorInfoNV\n";
            break;
        case 1000281000:
            settings.stream() << "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT\n";
            break;
        case 1000282001:
            settings.stream() << "VkRenderPassTransformBeginInfoQCOM\n";
            break;
        case 1000282000:
            settings.stream() << "VkCommandBufferInheritanceRenderPassTransformInfoQCOM\n";
            break;
        case 1000283000:
            settings.stream() << "VkPhysicalDeviceDepthBiasControlFeaturesEXT\n";
            break;
        case 1000283001:
            settings.stream() << "VkDepthBiasInfoEXT\n";
            break;
        case 1000283002:
            settings.stream() << "VkDepthBiasRepresentationInfoEXT\n";
            break;
        case 1000284000:
            settings.stream() << "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT\n";
            break;
        case 1000284002:
            settings.stream() << "VkDeviceMemoryReportCallbackDataEXT\n";
            break;
        case 1000284001:
            settings.stream() << "VkDeviceDeviceMemoryReportCreateInfoEXT\n";
            break;
        case 1000286000:
            settings.stream() << "VkPhysicalDeviceRobustness2FeaturesEXT\n";
            break;
        case 1000286001:
            settings.stream() << "VkPhysicalDeviceRobustness2PropertiesEXT\n";
            break;
        case 1000287000:
            settings.stream() << "VkSamplerCustomBorderColorCreateInfoEXT\n";
            break;
        case 1000287001:
            settings.stream() << "VkPhysicalDeviceCustomBorderColorPropertiesEXT\n";
            break;
        case 1000287002:
            settings.stream() << "VkPhysicalDeviceCustomBorderColorFeaturesEXT\n";
            break;
        case 1000292000:
            settings.stream() << "VkPhysicalDevicePresentBarrierFeaturesNV\n";
            break;
        case 1000292001:
            settings.stream() << "VkSurfaceCapabilitiesPresentBarrierNV\n";
            break;
        case 1000292002:
            settings.stream() << "VkSwapchainPresentBarrierCreateInfoNV\n";
            break;
        case 1000294000:
            settings.stream() << "VkPresentIdKHR\n";
            break;
        case 1000294001:
            settings.stream() << "VkPhysicalDevicePresentIdFeaturesKHR\n";
            break;
        case 1000299000:
            settings.stream() << "VkVideoEncodeInfoKHR\n";
            break;
        case 1000299003:
            settings.stream() << "VkVideoEncodeCapabilitiesKHR\n";
            break;
        case 1000299005:
            settings.stream() << "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR\n";
            break;
        case 1000299004:
            settings.stream() << "VkVideoEncodeUsageInfoKHR\n";
            break;
        case 1000299002:
            settings.stream() << "VkVideoEncodeRateControlLayerInfoKHR\n";
            break;
        case 1000299001:
            settings.stream() << "VkVideoEncodeRateControlInfoKHR\n";
            break;
        case 1000299006:
            settings.stream() << "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR\n";
            break;
        case 1000299007:
            settings.stream() << "VkVideoEncodeQualityLevelPropertiesKHR\n";
            break;
        case 1000299008:
            settings.stream() << "VkVideoEncodeQualityLevelInfoKHR\n";
            break;
        case 1000299009:
            settings.stream() << "VkVideoEncodeSessionParametersGetInfoKHR\n";
            break;
        case 1000299010:
            settings.stream() << "VkVideoEncodeSessionParametersFeedbackInfoKHR\n";
            break;
        case 1000300000:
            settings.stream() << "VkPhysicalDeviceDiagnosticsConfigFeaturesNV\n";
            break;
        case 1000300001:
            settings.stream() << "VkDeviceDiagnosticsConfigCreateInfoNV\n";
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000307000:
            settings.stream() << "VkCudaModuleCreateInfoNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000307001:
            settings.stream() << "VkCudaFunctionCreateInfoNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000307002:
            settings.stream() << "VkCudaLaunchInfoNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000307003:
            settings.stream() << "VkPhysicalDeviceCudaKernelLaunchFeaturesNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000307004:
            settings.stream() << "VkPhysicalDeviceCudaKernelLaunchPropertiesNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000309000:
            settings.stream() << "VkPhysicalDeviceTileShadingFeaturesQCOM\n";
            break;
        case 1000309001:
            settings.stream() << "VkPhysicalDeviceTileShadingPropertiesQCOM\n";
            break;
        case 1000309002:
            settings.stream() << "VkRenderPassTileShadingCreateInfoQCOM\n";
            break;
        case 1000309003:
            settings.stream() << "VkPerTileBeginInfoQCOM\n";
            break;
        case 1000309004:
            settings.stream() << "VkPerTileEndInfoQCOM\n";
            break;
        case 1000309005:
            settings.stream() << "VkDispatchTileInfoQCOM\n";
            break;
        case 1000310000:
            settings.stream() << "VkQueryLowLatencySupportNV\n";
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311000:
            settings.stream() << "VkExportMetalObjectCreateInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311001:
            settings.stream() << "VkExportMetalObjectsInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311002:
            settings.stream() << "VkExportMetalDeviceInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311003:
            settings.stream() << "VkExportMetalCommandQueueInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311004:
            settings.stream() << "VkExportMetalBufferInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311005:
            settings.stream() << "VkImportMetalBufferInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311006:
            settings.stream() << "VkExportMetalTextureInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311007:
            settings.stream() << "VkImportMetalTextureInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311008:
            settings.stream() << "VkExportMetalIOSurfaceInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311009:
            settings.stream() << "VkImportMetalIOSurfaceInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311010:
            settings.stream() << "VkExportMetalSharedEventInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000311011:
            settings.stream() << "VkImportMetalSharedEventInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
        case 1000316000:
            settings.stream() << "VkPhysicalDeviceDescriptorBufferPropertiesEXT\n";
            break;
        case 1000316001:
            settings.stream() << "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT\n";
            break;
        case 1000316002:
            settings.stream() << "VkPhysicalDeviceDescriptorBufferFeaturesEXT\n";
            break;
        case 1000316003:
            settings.stream() << "VkDescriptorAddressInfoEXT\n";
            break;
        case 1000316011:
            settings.stream() << "VkDescriptorBufferBindingInfoEXT\n";
            break;
        case 1000316012:
            settings.stream() << "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT\n";
            break;
        case 1000316004:
            settings.stream() << "VkDescriptorGetInfoEXT\n";
            break;
        case 1000316005:
            settings.stream() << "VkBufferCaptureDescriptorDataInfoEXT\n";
            break;
        case 1000316006:
            settings.stream() << "VkImageCaptureDescriptorDataInfoEXT\n";
            break;
        case 1000316007:
            settings.stream() << "VkImageViewCaptureDescriptorDataInfoEXT\n";
            break;
        case 1000316008:
            settings.stream() << "VkSamplerCaptureDescriptorDataInfoEXT\n";
            break;
        case 1000316010:
            settings.stream() << "VkOpaqueCaptureDescriptorDataCreateInfoEXT\n";
            break;
        case 1000316009:
            settings.stream() << "VkAccelerationStructureCaptureDescriptorDataInfoEXT\n";
            break;
        case 1000320000:
            settings.stream() << "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT\n";
            break;
        case 1000320001:
            settings.stream() << "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT\n";
            break;
        case 1000320002:
            settings.stream() << "VkGraphicsPipelineLibraryCreateInfoEXT\n";
            break;
        case 1000321000:
            settings.stream() << "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD\n";
            break;
        case 1000322000:
            settings.stream() << "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR\n";
            break;
        case 1000323000:
            settings.stream() << "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR\n";
            break;
        case 1000326001:
            settings.stream() << "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV\n";
            break;
        case 1000326000:
            settings.stream() << "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV\n";
            break;
        case 1000326002:
            settings.stream() << "VkPipelineFragmentShadingRateEnumStateCreateInfoNV\n";
            break;
        case 1000327000:
            settings.stream() << "VkAccelerationStructureGeometryMotionTrianglesDataNV\n";
            break;
        case 1000327002:
            settings.stream() << "VkAccelerationStructureMotionInfoNV\n";
            break;
        case 1000327001:
            settings.stream() << "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV\n";
            break;
        case 1000328000:
            settings.stream() << "VkPhysicalDeviceMeshShaderFeaturesEXT\n";
            break;
        case 1000328001:
            settings.stream() << "VkPhysicalDeviceMeshShaderPropertiesEXT\n";
            break;
        case 1000330000:
            settings.stream() << "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT\n";
            break;
        case 1000332000:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT\n";
            break;
        case 1000332001:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT\n";
            break;
        case 1000333000:
            settings.stream() << "VkCopyCommandTransformInfoQCOM\n";
            break;
        case 1000336000:
            settings.stream() << "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR\n";
            break;
        case 1000338000:
            settings.stream() << "VkPhysicalDeviceImageCompressionControlFeaturesEXT\n";
            break;
        case 1000338001:
            settings.stream() << "VkImageCompressionControlEXT\n";
            break;
        case 1000338004:
            settings.stream() << "VkImageCompressionPropertiesEXT\n";
            break;
        case 1000339000:
            settings.stream() << "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT\n";
            break;
        case 1000340000:
            settings.stream() << "VkPhysicalDevice4444FormatsFeaturesEXT\n";
            break;
        case 1000341000:
            settings.stream() << "VkPhysicalDeviceFaultFeaturesEXT\n";
            break;
        case 1000341001:
            settings.stream() << "VkDeviceFaultCountsEXT\n";
            break;
        case 1000341002:
            settings.stream() << "VkDeviceFaultInfoEXT\n";
            break;
        case 1000342000:
            settings.stream() << "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT\n";
            break;
        case 1000344000:
            settings.stream() << "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
        case 1000346000:
            settings.stream() << "VkDirectFBSurfaceCreateInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
        case 1000150016:
            settings.stream() << "VkRayTracingShaderGroupCreateInfoKHR\n";
            break;
        case 1000150018:
            settings.stream() << "VkRayTracingPipelineInterfaceCreateInfoKHR\n";
            break;
        case 1000150015:
            settings.stream() << "VkRayTracingPipelineCreateInfoKHR\n";
            break;
        case 1000347000:
            settings.stream() << "VkPhysicalDeviceRayTracingPipelineFeaturesKHR\n";
            break;
        case 1000347001:
            settings.stream() << "VkPhysicalDeviceRayTracingPipelinePropertiesKHR\n";
            break;
        case 1000348013:
            settings.stream() << "VkPhysicalDeviceRayQueryFeaturesKHR\n";
            break;
        case 1000351000:
            settings.stream() << "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT\n";
            break;
        case 1000351002:
            settings.stream() << "VkMutableDescriptorTypeCreateInfoEXT\n";
            break;
        case 1000352000:
            settings.stream() << "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT\n";
            break;
        case 1000352001:
            settings.stream() << "VkVertexInputBindingDescription2EXT\n";
            break;
        case 1000352002:
            settings.stream() << "VkVertexInputAttributeDescription2EXT\n";
            break;
        case 1000353000:
            settings.stream() << "VkPhysicalDeviceDrmPropertiesEXT\n";
            break;
        case 1000354000:
            settings.stream() << "VkPhysicalDeviceAddressBindingReportFeaturesEXT\n";
            break;
        case 1000354001:
            settings.stream() << "VkDeviceAddressBindingCallbackDataEXT\n";
            break;
        case 1000355000:
            settings.stream() << "VkPhysicalDeviceDepthClipControlFeaturesEXT\n";
            break;
        case 1000355001:
            settings.stream() << "VkPipelineViewportDepthClipControlCreateInfoEXT\n";
            break;
        case 1000356000:
            settings.stream() << "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT\n";
            break;
        case 1000361000:
            settings.stream() << "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000364000:
            settings.stream() << "VkImportMemoryZirconHandleInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000364001:
            settings.stream() << "VkMemoryZirconHandlePropertiesFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000364002:
            settings.stream() << "VkMemoryGetZirconHandleInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000365000:
            settings.stream() << "VkImportSemaphoreZirconHandleInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000365001:
            settings.stream() << "VkSemaphoreGetZirconHandleInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366000:
            settings.stream() << "VkBufferCollectionCreateInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366001:
            settings.stream() << "VkImportMemoryBufferCollectionFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366002:
            settings.stream() << "VkBufferCollectionImageCreateInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366009:
            settings.stream() << "VkBufferCollectionConstraintsInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366004:
            settings.stream() << "VkBufferConstraintsInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366005:
            settings.stream() << "VkBufferCollectionBufferCreateInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366008:
            settings.stream() << "VkSysmemColorSpaceFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366003:
            settings.stream() << "VkBufferCollectionPropertiesFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366007:
            settings.stream() << "VkImageFormatConstraintsInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
        case 1000366006:
            settings.stream() << "VkImageConstraintsInfoFUCHSIA\n";
            break;
#endif // VK_USE_PLATFORM_FUCHSIA
        case 1000369000:
            settings.stream() << "VkSubpassShadingPipelineCreateInfoHUAWEI\n";
            break;
        case 1000369001:
            settings.stream() << "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI\n";
            break;
        case 1000369002:
            settings.stream() << "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI\n";
            break;
        case 1000370000:
            settings.stream() << "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI\n";
            break;
        case 1000371000:
            settings.stream() << "VkMemoryGetRemoteAddressInfoNV\n";
            break;
        case 1000371001:
            settings.stream() << "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV\n";
            break;
        case 1000372000:
            settings.stream() << "VkPipelinePropertiesIdentifierEXT\n";
            break;
        case 1000372001:
            settings.stream() << "VkPhysicalDevicePipelinePropertiesFeaturesEXT\n";
            break;
        case 1000375000:
            settings.stream() << "VkPhysicalDeviceFrameBoundaryFeaturesEXT\n";
            break;
        case 1000375001:
            settings.stream() << "VkFrameBoundaryEXT\n";
            break;
        case 1000376000:
            settings.stream() << "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT\n";
            break;
        case 1000376001:
            settings.stream() << "VkSubpassResolvePerformanceQueryEXT\n";
            break;
        case 1000376002:
            settings.stream() << "VkMultisampledRenderToSingleSampledInfoEXT\n";
            break;
        case 1000377000:
            settings.stream() << "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000378000:
            settings.stream() << "VkScreenSurfaceCreateInfoQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
        case 1000381000:
            settings.stream() << "VkPhysicalDeviceColorWriteEnableFeaturesEXT\n";
            break;
        case 1000381001:
            settings.stream() << "VkPipelineColorWriteCreateInfoEXT\n";
            break;
        case 1000382000:
            settings.stream() << "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT\n";
            break;
        case 1000386000:
            settings.stream() << "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR\n";
            break;
        case 1000391000:
            settings.stream() << "VkPhysicalDeviceImageViewMinLodFeaturesEXT\n";
            break;
        case 1000391001:
            settings.stream() << "VkImageViewMinLodCreateInfoEXT\n";
            break;
        case 1000392000:
            settings.stream() << "VkPhysicalDeviceMultiDrawFeaturesEXT\n";
            break;
        case 1000392001:
            settings.stream() << "VkPhysicalDeviceMultiDrawPropertiesEXT\n";
            break;
        case 1000393000:
            settings.stream() << "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT\n";
            break;
        case 1000395000:
            settings.stream() << "VkPhysicalDeviceShaderTileImageFeaturesEXT\n";
            break;
        case 1000395001:
            settings.stream() << "VkPhysicalDeviceShaderTileImagePropertiesEXT\n";
            break;
        case 1000396000:
            settings.stream() << "VkMicromapBuildInfoEXT\n";
            break;
        case 1000396007:
            settings.stream() << "VkMicromapCreateInfoEXT\n";
            break;
        case 1000396005:
            settings.stream() << "VkPhysicalDeviceOpacityMicromapFeaturesEXT\n";
            break;
        case 1000396006:
            settings.stream() << "VkPhysicalDeviceOpacityMicromapPropertiesEXT\n";
            break;
        case 1000396001:
            settings.stream() << "VkMicromapVersionInfoEXT\n";
            break;
        case 1000396003:
            settings.stream() << "VkCopyMicromapToMemoryInfoEXT\n";
            break;
        case 1000396004:
            settings.stream() << "VkCopyMemoryToMicromapInfoEXT\n";
            break;
        case 1000396002:
            settings.stream() << "VkCopyMicromapInfoEXT\n";
            break;
        case 1000396008:
            settings.stream() << "VkMicromapBuildSizesInfoEXT\n";
            break;
        case 1000396009:
            settings.stream() << "VkAccelerationStructureTrianglesOpacityMicromapEXT\n";
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000397000:
            settings.stream() << "VkPhysicalDeviceDisplacementMicromapFeaturesNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000397001:
            settings.stream() << "VkPhysicalDeviceDisplacementMicromapPropertiesNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000397002:
            settings.stream() << "VkAccelerationStructureTrianglesDisplacementMicromapNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000404000:
            settings.stream() << "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI\n";
            break;
        case 1000404001:
            settings.stream() << "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI\n";
            break;
        case 1000404002:
            settings.stream() << "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI\n";
            break;
        case 1000411000:
            settings.stream() << "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT\n";
            break;
        case 1000411001:
            settings.stream() << "VkSamplerBorderColorComponentMappingCreateInfoEXT\n";
            break;
        case 1000412000:
            settings.stream() << "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT\n";
            break;
        case 1000415000:
            settings.stream() << "VkPhysicalDeviceShaderCorePropertiesARM\n";
            break;
        case 1000417000:
            settings.stream() << "VkDeviceQueueShaderCoreControlCreateInfoARM\n";
            break;
        case 1000417001:
            settings.stream() << "VkPhysicalDeviceSchedulingControlsFeaturesARM\n";
            break;
        case 1000417002:
            settings.stream() << "VkPhysicalDeviceSchedulingControlsPropertiesARM\n";
            break;
        case 1000418000:
            settings.stream() << "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT\n";
            break;
        case 1000418001:
            settings.stream() << "VkImageViewSlicedCreateInfoEXT\n";
            break;
        case 1000420000:
            settings.stream() << "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE\n";
            break;
        case 1000420001:
            settings.stream() << "VkDescriptorSetBindingReferenceVALVE\n";
            break;
        case 1000420002:
            settings.stream() << "VkDescriptorSetLayoutHostMappingInfoVALVE\n";
            break;
        case 1000421000:
            settings.stream() << "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR\n";
            break;
        case 1000422000:
            settings.stream() << "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT\n";
            break;
        case 1000424000:
            settings.stream() << "VkPhysicalDeviceRenderPassStripedFeaturesARM\n";
            break;
        case 1000424001:
            settings.stream() << "VkPhysicalDeviceRenderPassStripedPropertiesARM\n";
            break;
        case 1000424003:
            settings.stream() << "VkRenderPassStripeInfoARM\n";
            break;
        case 1000424002:
            settings.stream() << "VkRenderPassStripeBeginInfoARM\n";
            break;
        case 1000424004:
            settings.stream() << "VkRenderPassStripeSubmitInfoARM\n";
            break;
        case 1000425000:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT\n";
            break;
        case 1000425001:
            settings.stream() << "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT\n";
            break;
        case 1000425002:
            settings.stream() << "VkRenderPassFragmentDensityMapOffsetEndInfoEXT\n";
            break;
        case 1000426000:
            settings.stream() << "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV\n";
            break;
        case 1000426001:
            settings.stream() << "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV\n";
            break;
        case 1000427000:
            settings.stream() << "VkPhysicalDeviceMemoryDecompressionFeaturesNV\n";
            break;
        case 1000427001:
            settings.stream() << "VkPhysicalDeviceMemoryDecompressionPropertiesNV\n";
            break;
        case 1000428000:
            settings.stream() << "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV\n";
            break;
        case 1000428001:
            settings.stream() << "VkComputePipelineIndirectBufferInfoNV\n";
            break;
        case 1000428002:
            settings.stream() << "VkPipelineIndirectDeviceAddressInfoNV\n";
            break;
        case 1000429008:
            settings.stream() << "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV\n";
            break;
        case 1000429009:
            settings.stream() << "VkAccelerationStructureGeometryLinearSweptSpheresDataNV\n";
            break;
        case 1000429010:
            settings.stream() << "VkAccelerationStructureGeometrySpheresDataNV\n";
            break;
        case 1000430000:
            settings.stream() << "VkPhysicalDeviceLinearColorAttachmentFeaturesNV\n";
            break;
        case 1000434000:
            settings.stream() << "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR\n";
            break;
        case 1000437000:
            settings.stream() << "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT\n";
            break;
        case 1000440002:
            settings.stream() << "VkImageViewSampleWeightCreateInfoQCOM\n";
            break;
        case 1000440000:
            settings.stream() << "VkPhysicalDeviceImageProcessingFeaturesQCOM\n";
            break;
        case 1000440001:
            settings.stream() << "VkPhysicalDeviceImageProcessingPropertiesQCOM\n";
            break;
        case 1000451000:
            settings.stream() << "VkPhysicalDeviceNestedCommandBufferFeaturesEXT\n";
            break;
        case 1000451001:
            settings.stream() << "VkPhysicalDeviceNestedCommandBufferPropertiesEXT\n";
            break;
        case 1000453000:
            settings.stream() << "VkExternalMemoryAcquireUnmodifiedEXT\n";
            break;
        case 1000455000:
            settings.stream() << "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT\n";
            break;
        case 1000455001:
            settings.stream() << "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT\n";
            break;
        case 1000458000:
            settings.stream() << "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT\n";
            break;
        case 1000458001:
            settings.stream() << "VkRenderPassCreationControlEXT\n";
            break;
        case 1000458002:
            settings.stream() << "VkRenderPassCreationFeedbackCreateInfoEXT\n";
            break;
        case 1000458003:
            settings.stream() << "VkRenderPassSubpassFeedbackCreateInfoEXT\n";
            break;
        case 1000459000:
            settings.stream() << "VkDirectDriverLoadingInfoLUNARG\n";
            break;
        case 1000459001:
            settings.stream() << "VkDirectDriverLoadingListLUNARG\n";
            break;
        case 1000462000:
            settings.stream() << "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT\n";
            break;
        case 1000462001:
            settings.stream() << "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT\n";
            break;
        case 1000462002:
            settings.stream() << "VkPipelineShaderStageModuleIdentifierCreateInfoEXT\n";
            break;
        case 1000462003:
            settings.stream() << "VkShaderModuleIdentifierEXT\n";
            break;
        case 1000464000:
            settings.stream() << "VkPhysicalDeviceOpticalFlowFeaturesNV\n";
            break;
        case 1000464001:
            settings.stream() << "VkPhysicalDeviceOpticalFlowPropertiesNV\n";
            break;
        case 1000464002:
            settings.stream() << "VkOpticalFlowImageFormatInfoNV\n";
            break;
        case 1000464003:
            settings.stream() << "VkOpticalFlowImageFormatPropertiesNV\n";
            break;
        case 1000464004:
            settings.stream() << "VkOpticalFlowSessionCreateInfoNV\n";
            break;
        case 1000464010:
            settings.stream() << "VkOpticalFlowSessionCreatePrivateDataInfoNV\n";
            break;
        case 1000464005:
            settings.stream() << "VkOpticalFlowExecuteInfoNV\n";
            break;
        case 1000465000:
            settings.stream() << "VkPhysicalDeviceLegacyDitheringFeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000468000:
            settings.stream() << "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000468001:
            settings.stream() << "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
        case 1000468002:
            settings.stream() << "VkAndroidHardwareBufferFormatResolvePropertiesANDROID\n";
            break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
        case 1000476000:
            settings.stream() << "VkPhysicalDeviceAntiLagFeaturesAMD\n";
            break;
        case 1000476002:
            settings.stream() << "VkAntiLagPresentationInfoAMD\n";
            break;
        case 1000476001:
            settings.stream() << "VkAntiLagDataAMD\n";
            break;
        case 1000481000:
            settings.stream() << "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR\n";
            break;
        case 1000482000:
            settings.stream() << "VkPhysicalDeviceShaderObjectFeaturesEXT\n";
            break;
        case 1000482001:
            settings.stream() << "VkPhysicalDeviceShaderObjectPropertiesEXT\n";
            break;
        case 1000482002:
            settings.stream() << "VkShaderCreateInfoEXT\n";
            break;
        case 1000483000:
            settings.stream() << "VkPhysicalDevicePipelineBinaryFeaturesKHR\n";
            break;
        case 1000483004:
            settings.stream() << "VkPhysicalDevicePipelineBinaryPropertiesKHR\n";
            break;
        case 1000483008:
            settings.stream() << "VkDevicePipelineBinaryInternalCacheControlKHR\n";
            break;
        case 1000483003:
            settings.stream() << "VkPipelineBinaryKeyKHR\n";
            break;
        case 1000483007:
            settings.stream() << "VkPipelineCreateInfoKHR\n";
            break;
        case 1000483001:
            settings.stream() << "VkPipelineBinaryCreateInfoKHR\n";
            break;
        case 1000483002:
            settings.stream() << "VkPipelineBinaryInfoKHR\n";
            break;
        case 1000483005:
            settings.stream() << "VkReleaseCapturedPipelineDataInfoKHR\n";
            break;
        case 1000483006:
            settings.stream() << "VkPipelineBinaryDataInfoKHR\n";
            break;
        case 1000483009:
            settings.stream() << "VkPipelineBinaryHandlesInfoKHR\n";
            break;
        case 1000484000:
            settings.stream() << "VkPhysicalDeviceTilePropertiesFeaturesQCOM\n";
            break;
        case 1000484001:
            settings.stream() << "VkTilePropertiesQCOM\n";
            break;
        case 1000485000:
            settings.stream() << "VkPhysicalDeviceAmigoProfilingFeaturesSEC\n";
            break;
        case 1000485001:
            settings.stream() << "VkAmigoProfilingSubmitInfoSEC\n";
            break;
        case 1000488000:
            settings.stream() << "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM\n";
            break;
        case 1000490001:
            settings.stream() << "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV\n";
            break;
        case 1000490000:
            settings.stream() << "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV\n";
            break;
        case 1000491001:
            settings.stream() << "VkPhysicalDeviceCooperativeVectorPropertiesNV\n";
            break;
        case 1000491000:
            settings.stream() << "VkPhysicalDeviceCooperativeVectorFeaturesNV\n";
            break;
        case 1000491002:
            settings.stream() << "VkCooperativeVectorPropertiesNV\n";
            break;
        case 1000491004:
            settings.stream() << "VkConvertCooperativeVectorMatrixInfoNV\n";
            break;
        case 1000492000:
            settings.stream() << "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV\n";
            break;
        case 1000492001:
            settings.stream() << "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV\n";
            break;
        case 1000495000:
            settings.stream() << "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT\n";
            break;
        case 1000495001:
            settings.stream() << "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT\n";
            break;
        case 1000496000:
            settings.stream() << "VkLayerSettingsCreateInfoEXT\n";
            break;
        case 1000497000:
            settings.stream() << "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM\n";
            break;
        case 1000497001:
            settings.stream() << "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM\n";
            break;
        case 1000498000:
            settings.stream() << "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT\n";
            break;
        case 1000499000:
            settings.stream() << "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT\n";
            break;
        case 1000505000:
            settings.stream() << "VkLatencySleepModeInfoNV\n";
            break;
        case 1000505001:
            settings.stream() << "VkLatencySleepInfoNV\n";
            break;
        case 1000505002:
            settings.stream() << "VkSetLatencyMarkerInfoNV\n";
            break;
        case 1000505004:
            settings.stream() << "VkLatencyTimingsFrameReportNV\n";
            break;
        case 1000505003:
            settings.stream() << "VkGetLatencyMarkerInfoNV\n";
            break;
        case 1000505005:
            settings.stream() << "VkLatencySubmissionPresentIdNV\n";
            break;
        case 1000505007:
            settings.stream() << "VkSwapchainLatencyCreateInfoNV\n";
            break;
        case 1000505006:
            settings.stream() << "VkOutOfBandQueueTypeInfoNV\n";
            break;
        case 1000505008:
            settings.stream() << "VkLatencySurfaceCapabilitiesNV\n";
            break;
        case 1000506001:
            settings.stream() << "VkCooperativeMatrixPropertiesKHR\n";
            break;
        case 1000506000:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrixFeaturesKHR\n";
            break;
        case 1000506002:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrixPropertiesKHR\n";
            break;
        case 1000510000:
            settings.stream() << "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM\n";
            break;
        case 1000510001:
            settings.stream() << "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM\n";
            break;
        case 1000511000:
            settings.stream() << "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR\n";
            break;
        case 1000512003:
            settings.stream() << "VkVideoDecodeAV1ProfileInfoKHR\n";
            break;
        case 1000512000:
            settings.stream() << "VkVideoDecodeAV1CapabilitiesKHR\n";
            break;
        case 1000512004:
            settings.stream() << "VkVideoDecodeAV1SessionParametersCreateInfoKHR\n";
            break;
        case 1000512001:
            settings.stream() << "VkVideoDecodeAV1PictureInfoKHR\n";
            break;
        case 1000512005:
            settings.stream() << "VkVideoDecodeAV1DpbSlotInfoKHR\n";
            break;
        case 1000513004:
            settings.stream() << "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR\n";
            break;
        case 1000513000:
            settings.stream() << "VkVideoEncodeAV1CapabilitiesKHR\n";
            break;
        case 1000513008:
            settings.stream() << "VkVideoEncodeAV1QualityLevelPropertiesKHR\n";
            break;
        case 1000513009:
            settings.stream() << "VkVideoEncodeAV1SessionCreateInfoKHR\n";
            break;
        case 1000513001:
            settings.stream() << "VkVideoEncodeAV1SessionParametersCreateInfoKHR\n";
            break;
        case 1000513002:
            settings.stream() << "VkVideoEncodeAV1PictureInfoKHR\n";
            break;
        case 1000513003:
            settings.stream() << "VkVideoEncodeAV1DpbSlotInfoKHR\n";
            break;
        case 1000513005:
            settings.stream() << "VkVideoEncodeAV1ProfileInfoKHR\n";
            break;
        case 1000513010:
            settings.stream() << "VkVideoEncodeAV1GopRemainingFrameInfoKHR\n";
            break;
        case 1000513006:
            settings.stream() << "VkVideoEncodeAV1RateControlInfoKHR\n";
            break;
        case 1000513007:
            settings.stream() << "VkVideoEncodeAV1RateControlLayerInfoKHR\n";
            break;
        case 1000515000:
            settings.stream() << "VkPhysicalDeviceVideoMaintenance1FeaturesKHR\n";
            break;
        case 1000515001:
            settings.stream() << "VkVideoInlineQueryInfoKHR\n";
            break;
        case 1000516000:
            settings.stream() << "VkPhysicalDevicePerStageDescriptorSetFeaturesNV\n";
            break;
        case 1000518000:
            settings.stream() << "VkPhysicalDeviceImageProcessing2FeaturesQCOM\n";
            break;
        case 1000518001:
            settings.stream() << "VkPhysicalDeviceImageProcessing2PropertiesQCOM\n";
            break;
        case 1000518002:
            settings.stream() << "VkSamplerBlockMatchWindowCreateInfoQCOM\n";
            break;
        case 1000519001:
            settings.stream() << "VkPhysicalDeviceCubicWeightsFeaturesQCOM\n";
            break;
        case 1000519000:
            settings.stream() << "VkSamplerCubicWeightsCreateInfoQCOM\n";
            break;
        case 1000519002:
            settings.stream() << "VkBlitImageCubicWeightsInfoQCOM\n";
            break;
        case 1000520000:
            settings.stream() << "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM\n";
            break;
        case 1000520001:
            settings.stream() << "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM\n";
            break;
        case 1000521000:
            settings.stream() << "VkPhysicalDeviceCubicClampFeaturesQCOM\n";
            break;
        case 1000524000:
            settings.stream() << "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT\n";
            break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000529000:
            settings.stream() << "VkScreenBufferPropertiesQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000529001:
            settings.stream() << "VkScreenBufferFormatPropertiesQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000529002:
            settings.stream() << "VkImportScreenBufferInfoQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000529003:
            settings.stream() << "VkExternalFormatQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
        case 1000529004:
            settings.stream() << "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX\n";
            break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
        case 1000530000:
            settings.stream() << "VkPhysicalDeviceLayeredDriverPropertiesMSFT\n";
            break;
        case 1000545007:
            settings.stream() << "VkSetDescriptorBufferOffsetsInfoEXT\n";
            break;
        case 1000545008:
            settings.stream() << "VkBindDescriptorBufferEmbeddedSamplersInfoEXT\n";
            break;
        case 1000546000:
            settings.stream() << "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV\n";
            break;
        case 1000547000:
            settings.stream() << "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM\n";
            break;
        case 1000547001:
            settings.stream() << "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM\n";
            break;
        case 1000547002:
            settings.stream() << "VkTileMemoryRequirementsQCOM\n";
            break;
        case 1000547003:
            settings.stream() << "VkTileMemoryBindInfoQCOM\n";
            break;
        case 1000547004:
            settings.stream() << "VkTileMemorySizeInfoQCOM\n";
            break;
        case 1000551000:
            settings.stream() << "VkDisplaySurfaceStereoCreateInfoNV\n";
            break;
        case 1000551001:
            settings.stream() << "VkDisplayModeStereoPropertiesNV\n";
            break;
        case 1000553000:
            settings.stream() << "VkVideoEncodeQuantizationMapCapabilitiesKHR\n";
            break;
        case 1000553001:
            settings.stream() << "VkVideoFormatQuantizationMapPropertiesKHR\n";
            break;
        case 1000553002:
            settings.stream() << "VkVideoEncodeQuantizationMapInfoKHR\n";
            break;
        case 1000553005:
            settings.stream() << "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR\n";
            break;
        case 1000553009:
            settings.stream() << "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR\n";
            break;
        case 1000553003:
            settings.stream() << "VkVideoEncodeH264QuantizationMapCapabilitiesKHR\n";
            break;
        case 1000553004:
            settings.stream() << "VkVideoEncodeH265QuantizationMapCapabilitiesKHR\n";
            break;
        case 1000553006:
            settings.stream() << "VkVideoFormatH265QuantizationMapPropertiesKHR\n";
            break;
        case 1000553007:
            settings.stream() << "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR\n";
            break;
        case 1000553008:
            settings.stream() << "VkVideoFormatAV1QuantizationMapPropertiesKHR\n";
            break;
        case 1000555000:
            settings.stream() << "VkPhysicalDeviceRawAccessChainsFeaturesNV\n";
            break;
        case 1000556000:
            settings.stream() << "VkExternalComputeQueueDeviceCreateInfoNV\n";
            break;
        case 1000556001:
            settings.stream() << "VkExternalComputeQueueCreateInfoNV\n";
            break;
        case 1000556002:
            settings.stream() << "VkExternalComputeQueueDataParamsNV\n";
            break;
        case 1000556003:
            settings.stream() << "VkPhysicalDeviceExternalComputeQueuePropertiesNV\n";
            break;
        case 1000558000:
            settings.stream() << "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR\n";
            break;
        case 1000559000:
            settings.stream() << "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV\n";
            break;
        case 1000562000:
            settings.stream() << "VkPhysicalDeviceMaintenance7FeaturesKHR\n";
            break;
        case 1000562001:
            settings.stream() << "VkPhysicalDeviceMaintenance7PropertiesKHR\n";
            break;
        case 1000562003:
            settings.stream() << "VkPhysicalDeviceLayeredApiPropertiesKHR\n";
            break;
        case 1000562002:
            settings.stream() << "VkPhysicalDeviceLayeredApiPropertiesListKHR\n";
            break;
        case 1000562004:
            settings.stream() << "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR\n";
            break;
        case 1000563000:
            settings.stream() << "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV\n";
            break;
        case 1000564000:
            settings.stream() << "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT\n";
            break;
        case 1000568000:
            settings.stream() << "VkPhysicalDeviceRayTracingValidationFeaturesNV\n";
            break;
        case 1000569000:
            settings.stream() << "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV\n";
            break;
        case 1000569001:
            settings.stream() << "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV\n";
            break;
        case 1000569002:
            settings.stream() << "VkClusterAccelerationStructureClustersBottomLevelInputNV\n";
            break;
        case 1000569003:
            settings.stream() << "VkClusterAccelerationStructureTriangleClusterInputNV\n";
            break;
        case 1000569004:
            settings.stream() << "VkClusterAccelerationStructureMoveObjectsInputNV\n";
            break;
        case 1000569005:
            settings.stream() << "VkClusterAccelerationStructureInputInfoNV\n";
            break;
        case 1000569006:
            settings.stream() << "VkClusterAccelerationStructureCommandsInfoNV\n";
            break;
        case 1000569007:
            settings.stream() << "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV\n";
            break;
        case 1000570000:
            settings.stream() << "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV\n";
            break;
        case 1000570001:
            settings.stream() << "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV\n";
            break;
        case 1000570005:
            settings.stream() << "VkPartitionedAccelerationStructureFlagsNV\n";
            break;
        case 1000570002:
            settings.stream() << "VkWriteDescriptorSetPartitionedAccelerationStructureNV\n";
            break;
        case 1000570003:
            settings.stream() << "VkPartitionedAccelerationStructureInstancesInputNV\n";
            break;
        case 1000570004:
            settings.stream() << "VkBuildPartitionedAccelerationStructureInfoNV\n";
            break;
        case 1000572000:
            settings.stream() << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT\n";
            break;
        case 1000572001:
            settings.stream() << "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT\n";
            break;
        case 1000572002:
            settings.stream() << "VkGeneratedCommandsMemoryRequirementsInfoEXT\n";
            break;
        case 1000572010:
            settings.stream() << "VkIndirectExecutionSetPipelineInfoEXT\n";
            break;
        case 1000572012:
            settings.stream() << "VkIndirectExecutionSetShaderLayoutInfoEXT\n";
            break;
        case 1000572011:
            settings.stream() << "VkIndirectExecutionSetShaderInfoEXT\n";
            break;
        case 1000572003:
            settings.stream() << "VkIndirectExecutionSetCreateInfoEXT\n";
            break;
        case 1000572004:
            settings.stream() << "VkGeneratedCommandsInfoEXT\n";
            break;
        case 1000572008:
            settings.stream() << "VkWriteIndirectExecutionSetPipelineEXT\n";
            break;
        case 1000572007:
            settings.stream() << "VkIndirectCommandsLayoutTokenEXT\n";
            break;
        case 1000572006:
            settings.stream() << "VkIndirectCommandsLayoutCreateInfoEXT\n";
            break;
        case 1000572013:
            settings.stream() << "VkGeneratedCommandsPipelineInfoEXT\n";
            break;
        case 1000572014:
            settings.stream() << "VkGeneratedCommandsShaderInfoEXT\n";
            break;
        case 1000572009:
            settings.stream() << "VkWriteIndirectExecutionSetShaderEXT\n";
            break;
        case 1000574000:
            settings.stream() << "VkPhysicalDeviceMaintenance8FeaturesKHR\n";
            break;
        case 1000574002:
            settings.stream() << "VkMemoryBarrierAccessFlags3KHR\n";
            break;
        case 1000575000:
            settings.stream() << "VkPhysicalDeviceImageAlignmentControlFeaturesMESA\n";
            break;
        case 1000575001:
            settings.stream() << "VkPhysicalDeviceImageAlignmentControlPropertiesMESA\n";
            break;
        case 1000575002:
            settings.stream() << "VkImageAlignmentControlCreateInfoMESA\n";
            break;
        case 1000582000:
            settings.stream() << "VkPhysicalDeviceDepthClampControlFeaturesEXT\n";
            break;
        case 1000582001:
            settings.stream() << "VkPipelineViewportDepthClampControlCreateInfoEXT\n";
            break;
        case 1000586000:
            settings.stream() << "VkPhysicalDeviceVideoMaintenance2FeaturesKHR\n";
            break;
        case 1000586001:
            settings.stream() << "VkVideoDecodeH264InlineSessionParametersInfoKHR\n";
            break;
        case 1000586002:
            settings.stream() << "VkVideoDecodeH265InlineSessionParametersInfoKHR\n";
            break;
        case 1000586003:
            settings.stream() << "VkVideoDecodeAV1InlineSessionParametersInfoKHR\n";
            break;
        case 1000590000:
            settings.stream() << "VkPhysicalDeviceHdrVividFeaturesHUAWEI\n";
            break;
        case 1000590001:
            settings.stream() << "VkHdrVividDynamicMetadataHUAWEI\n";
            break;
        case 1000593001:
            settings.stream() << "VkCooperativeMatrixFlexibleDimensionsPropertiesNV\n";
            break;
        case 1000593000:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrix2FeaturesNV\n";
            break;
        case 1000593002:
            settings.stream() << "VkPhysicalDeviceCooperativeMatrix2PropertiesNV\n";
            break;
        case 1000596000:
            settings.stream() << "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM\n";
            break;
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000602000:
            settings.stream() << "VkImportMemoryMetalHandleInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000602001:
            settings.stream() << "VkMemoryMetalHandlePropertiesEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
        case 1000602002:
            settings.stream() << "VkMemoryGetMetalHandleInfoEXT\n";
            break;
#endif // VK_USE_PLATFORM_METAL_EXT
        case 1000608000:
            settings.stream() << "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT\n";
            break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000613000:
            settings.stream() << "VkSetPresentConfigNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
        case 1000613001:
            settings.stream() << "VkPhysicalDevicePresentMeteringFeaturesNV\n";
            break;
#endif // VK_ENABLE_BETA_EXTENSIONS
        case 1000619003:
            settings.stream() << "VkRenderingEndInfoEXT\n";
            break;
        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: // 47
        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: // 48
        default:
            settings.stream() << "NULL\n";
            break;
    }
}

void dump_text_pNext_trampoline(const void* object, const ApiDumpSettings& settings, int indents)
{
    const auto* base_struct = reinterpret_cast<const VkBaseInStructure*>(object);
    switch(base_struct->sType) {
    case 44:
        dump_text_pNext<const VkBufferMemoryBarrier>(reinterpret_cast<const VkBufferMemoryBarrier*>(object), settings, "VkBufferMemoryBarrier", indents, dump_text_VkBufferMemoryBarrier);
        break;
    case 45:
        dump_text_pNext<const VkImageMemoryBarrier>(reinterpret_cast<const VkImageMemoryBarrier*>(object), settings, "VkImageMemoryBarrier", indents, dump_text_VkImageMemoryBarrier);
        break;
    case 46:
        dump_text_pNext<const VkMemoryBarrier>(reinterpret_cast<const VkMemoryBarrier*>(object), settings, "VkMemoryBarrier", indents, dump_text_VkMemoryBarrier);
        break;
    case 0:
        dump_text_pNext<const VkApplicationInfo>(reinterpret_cast<const VkApplicationInfo*>(object), settings, "VkApplicationInfo", indents, dump_text_VkApplicationInfo);
        break;
    case 1:
        dump_text_pNext<const VkInstanceCreateInfo>(reinterpret_cast<const VkInstanceCreateInfo*>(object), settings, "VkInstanceCreateInfo", indents, dump_text_VkInstanceCreateInfo);
        break;
    case 2:
        dump_text_pNext<const VkDeviceQueueCreateInfo>(reinterpret_cast<const VkDeviceQueueCreateInfo*>(object), settings, "VkDeviceQueueCreateInfo", indents, dump_text_VkDeviceQueueCreateInfo);
        break;
    case 3:
        dump_text_pNext<const VkDeviceCreateInfo>(reinterpret_cast<const VkDeviceCreateInfo*>(object), settings, "VkDeviceCreateInfo", indents, dump_text_VkDeviceCreateInfo);
        break;
    case 4:
        dump_text_pNext<const VkSubmitInfo>(reinterpret_cast<const VkSubmitInfo*>(object), settings, "VkSubmitInfo", indents, dump_text_VkSubmitInfo);
        break;
    case 6:
        dump_text_pNext<const VkMappedMemoryRange>(reinterpret_cast<const VkMappedMemoryRange*>(object), settings, "VkMappedMemoryRange", indents, dump_text_VkMappedMemoryRange);
        break;
    case 5:
        dump_text_pNext<const VkMemoryAllocateInfo>(reinterpret_cast<const VkMemoryAllocateInfo*>(object), settings, "VkMemoryAllocateInfo", indents, dump_text_VkMemoryAllocateInfo);
        break;
    case 7:
        dump_text_pNext<const VkBindSparseInfo>(reinterpret_cast<const VkBindSparseInfo*>(object), settings, "VkBindSparseInfo", indents, dump_text_VkBindSparseInfo);
        break;
    case 8:
        dump_text_pNext<const VkFenceCreateInfo>(reinterpret_cast<const VkFenceCreateInfo*>(object), settings, "VkFenceCreateInfo", indents, dump_text_VkFenceCreateInfo);
        break;
    case 9:
        dump_text_pNext<const VkSemaphoreCreateInfo>(reinterpret_cast<const VkSemaphoreCreateInfo*>(object), settings, "VkSemaphoreCreateInfo", indents, dump_text_VkSemaphoreCreateInfo);
        break;
    case 10:
        dump_text_pNext<const VkEventCreateInfo>(reinterpret_cast<const VkEventCreateInfo*>(object), settings, "VkEventCreateInfo", indents, dump_text_VkEventCreateInfo);
        break;
    case 11:
        dump_text_pNext<const VkQueryPoolCreateInfo>(reinterpret_cast<const VkQueryPoolCreateInfo*>(object), settings, "VkQueryPoolCreateInfo", indents, dump_text_VkQueryPoolCreateInfo);
        break;
    case 12:
        dump_text_pNext<const VkBufferCreateInfo>(reinterpret_cast<const VkBufferCreateInfo*>(object), settings, "VkBufferCreateInfo", indents, dump_text_VkBufferCreateInfo);
        break;
    case 13:
        dump_text_pNext<const VkBufferViewCreateInfo>(reinterpret_cast<const VkBufferViewCreateInfo*>(object), settings, "VkBufferViewCreateInfo", indents, dump_text_VkBufferViewCreateInfo);
        break;
    case 14:
        dump_text_pNext<const VkImageCreateInfo>(reinterpret_cast<const VkImageCreateInfo*>(object), settings, "VkImageCreateInfo", indents, dump_text_VkImageCreateInfo);
        break;
    case 15:
        dump_text_pNext<const VkImageViewCreateInfo>(reinterpret_cast<const VkImageViewCreateInfo*>(object), settings, "VkImageViewCreateInfo", indents, dump_text_VkImageViewCreateInfo);
        break;
    case 16:
        dump_text_pNext<const VkShaderModuleCreateInfo>(reinterpret_cast<const VkShaderModuleCreateInfo*>(object), settings, "VkShaderModuleCreateInfo", indents, dump_text_VkShaderModuleCreateInfo);
        break;
    case 17:
        dump_text_pNext<const VkPipelineCacheCreateInfo>(reinterpret_cast<const VkPipelineCacheCreateInfo*>(object), settings, "VkPipelineCacheCreateInfo", indents, dump_text_VkPipelineCacheCreateInfo);
        break;
    case 18:
        dump_text_pNext<const VkPipelineShaderStageCreateInfo>(reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(object), settings, "VkPipelineShaderStageCreateInfo", indents, dump_text_VkPipelineShaderStageCreateInfo);
        break;
    case 29:
        dump_text_pNext<const VkComputePipelineCreateInfo>(reinterpret_cast<const VkComputePipelineCreateInfo*>(object), settings, "VkComputePipelineCreateInfo", indents, dump_text_VkComputePipelineCreateInfo);
        break;
    case 19:
        dump_text_pNext<const VkPipelineVertexInputStateCreateInfo>(reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(object), settings, "VkPipelineVertexInputStateCreateInfo", indents, dump_text_VkPipelineVertexInputStateCreateInfo);
        break;
    case 20:
        dump_text_pNext<const VkPipelineInputAssemblyStateCreateInfo>(reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(object), settings, "VkPipelineInputAssemblyStateCreateInfo", indents, dump_text_VkPipelineInputAssemblyStateCreateInfo);
        break;
    case 21:
        dump_text_pNext<const VkPipelineTessellationStateCreateInfo>(reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(object), settings, "VkPipelineTessellationStateCreateInfo", indents, dump_text_VkPipelineTessellationStateCreateInfo);
        break;
    case 22:
        dump_text_pNext<const VkPipelineViewportStateCreateInfo>(reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(object), settings, "VkPipelineViewportStateCreateInfo", indents, dump_text_VkPipelineViewportStateCreateInfo);
        break;
    case 23:
        dump_text_pNext<const VkPipelineRasterizationStateCreateInfo>(reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(object), settings, "VkPipelineRasterizationStateCreateInfo", indents, dump_text_VkPipelineRasterizationStateCreateInfo);
        break;
    case 24:
        dump_text_pNext<const VkPipelineMultisampleStateCreateInfo>(reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(object), settings, "VkPipelineMultisampleStateCreateInfo", indents, dump_text_VkPipelineMultisampleStateCreateInfo);
        break;
    case 25:
        dump_text_pNext<const VkPipelineDepthStencilStateCreateInfo>(reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(object), settings, "VkPipelineDepthStencilStateCreateInfo", indents, dump_text_VkPipelineDepthStencilStateCreateInfo);
        break;
    case 26:
        dump_text_pNext<const VkPipelineColorBlendStateCreateInfo>(reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(object), settings, "VkPipelineColorBlendStateCreateInfo", indents, dump_text_VkPipelineColorBlendStateCreateInfo);
        break;
    case 27:
        dump_text_pNext<const VkPipelineDynamicStateCreateInfo>(reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(object), settings, "VkPipelineDynamicStateCreateInfo", indents, dump_text_VkPipelineDynamicStateCreateInfo);
        break;
    case 28:
        dump_text_pNext<const VkGraphicsPipelineCreateInfo>(reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(object), settings, "VkGraphicsPipelineCreateInfo", indents, dump_text_VkGraphicsPipelineCreateInfo);
        break;
    case 30:
        dump_text_pNext<const VkPipelineLayoutCreateInfo>(reinterpret_cast<const VkPipelineLayoutCreateInfo*>(object), settings, "VkPipelineLayoutCreateInfo", indents, dump_text_VkPipelineLayoutCreateInfo);
        break;
    case 31:
        dump_text_pNext<const VkSamplerCreateInfo>(reinterpret_cast<const VkSamplerCreateInfo*>(object), settings, "VkSamplerCreateInfo", indents, dump_text_VkSamplerCreateInfo);
        break;
    case 36:
        dump_text_pNext<const VkCopyDescriptorSet>(reinterpret_cast<const VkCopyDescriptorSet*>(object), settings, "VkCopyDescriptorSet", indents, dump_text_VkCopyDescriptorSet);
        break;
    case 33:
        dump_text_pNext<const VkDescriptorPoolCreateInfo>(reinterpret_cast<const VkDescriptorPoolCreateInfo*>(object), settings, "VkDescriptorPoolCreateInfo", indents, dump_text_VkDescriptorPoolCreateInfo);
        break;
    case 34:
        dump_text_pNext<const VkDescriptorSetAllocateInfo>(reinterpret_cast<const VkDescriptorSetAllocateInfo*>(object), settings, "VkDescriptorSetAllocateInfo", indents, dump_text_VkDescriptorSetAllocateInfo);
        break;
    case 32:
        dump_text_pNext<const VkDescriptorSetLayoutCreateInfo>(reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(object), settings, "VkDescriptorSetLayoutCreateInfo", indents, dump_text_VkDescriptorSetLayoutCreateInfo);
        break;
    case 35:
        dump_text_pNext<const VkWriteDescriptorSet>(reinterpret_cast<const VkWriteDescriptorSet*>(object), settings, "VkWriteDescriptorSet", indents, dump_text_VkWriteDescriptorSet);
        break;
    case 37:
        dump_text_pNext<const VkFramebufferCreateInfo>(reinterpret_cast<const VkFramebufferCreateInfo*>(object), settings, "VkFramebufferCreateInfo", indents, dump_text_VkFramebufferCreateInfo);
        break;
    case 38:
        dump_text_pNext<const VkRenderPassCreateInfo>(reinterpret_cast<const VkRenderPassCreateInfo*>(object), settings, "VkRenderPassCreateInfo", indents, dump_text_VkRenderPassCreateInfo);
        break;
    case 39:
        dump_text_pNext<const VkCommandPoolCreateInfo>(reinterpret_cast<const VkCommandPoolCreateInfo*>(object), settings, "VkCommandPoolCreateInfo", indents, dump_text_VkCommandPoolCreateInfo);
        break;
    case 40:
        dump_text_pNext<const VkCommandBufferAllocateInfo>(reinterpret_cast<const VkCommandBufferAllocateInfo*>(object), settings, "VkCommandBufferAllocateInfo", indents, dump_text_VkCommandBufferAllocateInfo);
        break;
    case 41:
        dump_text_pNext<const VkCommandBufferInheritanceInfo>(reinterpret_cast<const VkCommandBufferInheritanceInfo*>(object), settings, "VkCommandBufferInheritanceInfo", indents, dump_text_VkCommandBufferInheritanceInfo);
        break;
    case 42:
        dump_text_pNext<const VkCommandBufferBeginInfo>(reinterpret_cast<const VkCommandBufferBeginInfo*>(object), settings, "VkCommandBufferBeginInfo", indents, dump_text_VkCommandBufferBeginInfo);
        break;
    case 43:
        dump_text_pNext<const VkRenderPassBeginInfo>(reinterpret_cast<const VkRenderPassBeginInfo*>(object), settings, "VkRenderPassBeginInfo", indents, dump_text_VkRenderPassBeginInfo);
        break;
    case 1000094000:
        dump_text_pNext<const VkPhysicalDeviceSubgroupProperties>(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(object), settings, "VkPhysicalDeviceSubgroupProperties", indents, dump_text_VkPhysicalDeviceSubgroupProperties);
        break;
    case 1000157000:
        dump_text_pNext<const VkBindBufferMemoryInfo>(reinterpret_cast<const VkBindBufferMemoryInfo*>(object), settings, "VkBindBufferMemoryInfo", indents, dump_text_VkBindBufferMemoryInfo);
        break;
    case 1000157001:
        dump_text_pNext<const VkBindImageMemoryInfo>(reinterpret_cast<const VkBindImageMemoryInfo*>(object), settings, "VkBindImageMemoryInfo", indents, dump_text_VkBindImageMemoryInfo);
        break;
    case 1000083000:
        dump_text_pNext<const VkPhysicalDevice16BitStorageFeatures>(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(object), settings, "VkPhysicalDevice16BitStorageFeatures", indents, dump_text_VkPhysicalDevice16BitStorageFeatures);
        break;
    case 1000127000:
        dump_text_pNext<const VkMemoryDedicatedRequirements>(reinterpret_cast<const VkMemoryDedicatedRequirements*>(object), settings, "VkMemoryDedicatedRequirements", indents, dump_text_VkMemoryDedicatedRequirements);
        break;
    case 1000127001:
        dump_text_pNext<const VkMemoryDedicatedAllocateInfo>(reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(object), settings, "VkMemoryDedicatedAllocateInfo", indents, dump_text_VkMemoryDedicatedAllocateInfo);
        break;
    case 1000060000:
        dump_text_pNext<const VkMemoryAllocateFlagsInfo>(reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(object), settings, "VkMemoryAllocateFlagsInfo", indents, dump_text_VkMemoryAllocateFlagsInfo);
        break;
    case 1000060003:
        dump_text_pNext<const VkDeviceGroupRenderPassBeginInfo>(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(object), settings, "VkDeviceGroupRenderPassBeginInfo", indents, dump_text_VkDeviceGroupRenderPassBeginInfo);
        break;
    case 1000060004:
        dump_text_pNext<const VkDeviceGroupCommandBufferBeginInfo>(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(object), settings, "VkDeviceGroupCommandBufferBeginInfo", indents, dump_text_VkDeviceGroupCommandBufferBeginInfo);
        break;
    case 1000060005:
        dump_text_pNext<const VkDeviceGroupSubmitInfo>(reinterpret_cast<const VkDeviceGroupSubmitInfo*>(object), settings, "VkDeviceGroupSubmitInfo", indents, dump_text_VkDeviceGroupSubmitInfo);
        break;
    case 1000060006:
        dump_text_pNext<const VkDeviceGroupBindSparseInfo>(reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(object), settings, "VkDeviceGroupBindSparseInfo", indents, dump_text_VkDeviceGroupBindSparseInfo);
        break;
    case 1000060013:
        dump_text_pNext<const VkBindBufferMemoryDeviceGroupInfo>(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(object), settings, "VkBindBufferMemoryDeviceGroupInfo", indents, dump_text_VkBindBufferMemoryDeviceGroupInfo);
        break;
    case 1000060014:
        dump_text_pNext<const VkBindImageMemoryDeviceGroupInfo>(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(object), settings, "VkBindImageMemoryDeviceGroupInfo", indents, dump_text_VkBindImageMemoryDeviceGroupInfo);
        break;
    case 1000070000:
        dump_text_pNext<const VkPhysicalDeviceGroupProperties>(reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(object), settings, "VkPhysicalDeviceGroupProperties", indents, dump_text_VkPhysicalDeviceGroupProperties);
        break;
    case 1000070001:
        dump_text_pNext<const VkDeviceGroupDeviceCreateInfo>(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(object), settings, "VkDeviceGroupDeviceCreateInfo", indents, dump_text_VkDeviceGroupDeviceCreateInfo);
        break;
    case 1000146000:
        dump_text_pNext<const VkBufferMemoryRequirementsInfo2>(reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(object), settings, "VkBufferMemoryRequirementsInfo2", indents, dump_text_VkBufferMemoryRequirementsInfo2);
        break;
    case 1000146001:
        dump_text_pNext<const VkImageMemoryRequirementsInfo2>(reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(object), settings, "VkImageMemoryRequirementsInfo2", indents, dump_text_VkImageMemoryRequirementsInfo2);
        break;
    case 1000146002:
        dump_text_pNext<const VkImageSparseMemoryRequirementsInfo2>(reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(object), settings, "VkImageSparseMemoryRequirementsInfo2", indents, dump_text_VkImageSparseMemoryRequirementsInfo2);
        break;
    case 1000146003:
        dump_text_pNext<const VkMemoryRequirements2>(reinterpret_cast<const VkMemoryRequirements2*>(object), settings, "VkMemoryRequirements2", indents, dump_text_VkMemoryRequirements2);
        break;
    case 1000146004:
        dump_text_pNext<const VkSparseImageMemoryRequirements2>(reinterpret_cast<const VkSparseImageMemoryRequirements2*>(object), settings, "VkSparseImageMemoryRequirements2", indents, dump_text_VkSparseImageMemoryRequirements2);
        break;
    case 1000059000:
        dump_text_pNext<const VkPhysicalDeviceFeatures2>(reinterpret_cast<const VkPhysicalDeviceFeatures2*>(object), settings, "VkPhysicalDeviceFeatures2", indents, dump_text_VkPhysicalDeviceFeatures2);
        break;
    case 1000059001:
        dump_text_pNext<const VkPhysicalDeviceProperties2>(reinterpret_cast<const VkPhysicalDeviceProperties2*>(object), settings, "VkPhysicalDeviceProperties2", indents, dump_text_VkPhysicalDeviceProperties2);
        break;
    case 1000059002:
        dump_text_pNext<const VkFormatProperties2>(reinterpret_cast<const VkFormatProperties2*>(object), settings, "VkFormatProperties2", indents, dump_text_VkFormatProperties2);
        break;
    case 1000059003:
        dump_text_pNext<const VkImageFormatProperties2>(reinterpret_cast<const VkImageFormatProperties2*>(object), settings, "VkImageFormatProperties2", indents, dump_text_VkImageFormatProperties2);
        break;
    case 1000059004:
        dump_text_pNext<const VkPhysicalDeviceImageFormatInfo2>(reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(object), settings, "VkPhysicalDeviceImageFormatInfo2", indents, dump_text_VkPhysicalDeviceImageFormatInfo2);
        break;
    case 1000059005:
        dump_text_pNext<const VkQueueFamilyProperties2>(reinterpret_cast<const VkQueueFamilyProperties2*>(object), settings, "VkQueueFamilyProperties2", indents, dump_text_VkQueueFamilyProperties2);
        break;
    case 1000059006:
        dump_text_pNext<const VkPhysicalDeviceMemoryProperties2>(reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(object), settings, "VkPhysicalDeviceMemoryProperties2", indents, dump_text_VkPhysicalDeviceMemoryProperties2);
        break;
    case 1000059007:
        dump_text_pNext<const VkSparseImageFormatProperties2>(reinterpret_cast<const VkSparseImageFormatProperties2*>(object), settings, "VkSparseImageFormatProperties2", indents, dump_text_VkSparseImageFormatProperties2);
        break;
    case 1000059008:
        dump_text_pNext<const VkPhysicalDeviceSparseImageFormatInfo2>(reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(object), settings, "VkPhysicalDeviceSparseImageFormatInfo2", indents, dump_text_VkPhysicalDeviceSparseImageFormatInfo2);
        break;
    case 1000117000:
        dump_text_pNext<const VkPhysicalDevicePointClippingProperties>(reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(object), settings, "VkPhysicalDevicePointClippingProperties", indents, dump_text_VkPhysicalDevicePointClippingProperties);
        break;
    case 1000117001:
        dump_text_pNext<const VkRenderPassInputAttachmentAspectCreateInfo>(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(object), settings, "VkRenderPassInputAttachmentAspectCreateInfo", indents, dump_text_VkRenderPassInputAttachmentAspectCreateInfo);
        break;
    case 1000117002:
        dump_text_pNext<const VkImageViewUsageCreateInfo>(reinterpret_cast<const VkImageViewUsageCreateInfo*>(object), settings, "VkImageViewUsageCreateInfo", indents, dump_text_VkImageViewUsageCreateInfo);
        break;
    case 1000117003:
        dump_text_pNext<const VkPipelineTessellationDomainOriginStateCreateInfo>(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(object), settings, "VkPipelineTessellationDomainOriginStateCreateInfo", indents, dump_text_VkPipelineTessellationDomainOriginStateCreateInfo);
        break;
    case 1000053000:
        dump_text_pNext<const VkRenderPassMultiviewCreateInfo>(reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(object), settings, "VkRenderPassMultiviewCreateInfo", indents, dump_text_VkRenderPassMultiviewCreateInfo);
        break;
    case 1000053001:
        dump_text_pNext<const VkPhysicalDeviceMultiviewFeatures>(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(object), settings, "VkPhysicalDeviceMultiviewFeatures", indents, dump_text_VkPhysicalDeviceMultiviewFeatures);
        break;
    case 1000053002:
        dump_text_pNext<const VkPhysicalDeviceMultiviewProperties>(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(object), settings, "VkPhysicalDeviceMultiviewProperties", indents, dump_text_VkPhysicalDeviceMultiviewProperties);
        break;
    case 1000120000:
        dump_text_pNext<const VkPhysicalDeviceVariablePointersFeatures>(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(object), settings, "VkPhysicalDeviceVariablePointersFeatures", indents, dump_text_VkPhysicalDeviceVariablePointersFeatures);
        break;
    case 1000145001:
        dump_text_pNext<const VkPhysicalDeviceProtectedMemoryFeatures>(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(object), settings, "VkPhysicalDeviceProtectedMemoryFeatures", indents, dump_text_VkPhysicalDeviceProtectedMemoryFeatures);
        break;
    case 1000145002:
        dump_text_pNext<const VkPhysicalDeviceProtectedMemoryProperties>(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(object), settings, "VkPhysicalDeviceProtectedMemoryProperties", indents, dump_text_VkPhysicalDeviceProtectedMemoryProperties);
        break;
    case 1000145003:
        dump_text_pNext<const VkDeviceQueueInfo2>(reinterpret_cast<const VkDeviceQueueInfo2*>(object), settings, "VkDeviceQueueInfo2", indents, dump_text_VkDeviceQueueInfo2);
        break;
    case 1000145000:
        dump_text_pNext<const VkProtectedSubmitInfo>(reinterpret_cast<const VkProtectedSubmitInfo*>(object), settings, "VkProtectedSubmitInfo", indents, dump_text_VkProtectedSubmitInfo);
        break;
    case 1000156000:
        dump_text_pNext<const VkSamplerYcbcrConversionCreateInfo>(reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(object), settings, "VkSamplerYcbcrConversionCreateInfo", indents, dump_text_VkSamplerYcbcrConversionCreateInfo);
        break;
    case 1000156001:
        dump_text_pNext<const VkSamplerYcbcrConversionInfo>(reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(object), settings, "VkSamplerYcbcrConversionInfo", indents, dump_text_VkSamplerYcbcrConversionInfo);
        break;
    case 1000156002:
        dump_text_pNext<const VkBindImagePlaneMemoryInfo>(reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(object), settings, "VkBindImagePlaneMemoryInfo", indents, dump_text_VkBindImagePlaneMemoryInfo);
        break;
    case 1000156003:
        dump_text_pNext<const VkImagePlaneMemoryRequirementsInfo>(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(object), settings, "VkImagePlaneMemoryRequirementsInfo", indents, dump_text_VkImagePlaneMemoryRequirementsInfo);
        break;
    case 1000156004:
        dump_text_pNext<const VkPhysicalDeviceSamplerYcbcrConversionFeatures>(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(object), settings, "VkPhysicalDeviceSamplerYcbcrConversionFeatures", indents, dump_text_VkPhysicalDeviceSamplerYcbcrConversionFeatures);
        break;
    case 1000156005:
        dump_text_pNext<const VkSamplerYcbcrConversionImageFormatProperties>(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(object), settings, "VkSamplerYcbcrConversionImageFormatProperties", indents, dump_text_VkSamplerYcbcrConversionImageFormatProperties);
        break;
    case 1000085000:
        dump_text_pNext<const VkDescriptorUpdateTemplateCreateInfo>(reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(object), settings, "VkDescriptorUpdateTemplateCreateInfo", indents, dump_text_VkDescriptorUpdateTemplateCreateInfo);
        break;
    case 1000071000:
        dump_text_pNext<const VkPhysicalDeviceExternalImageFormatInfo>(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(object), settings, "VkPhysicalDeviceExternalImageFormatInfo", indents, dump_text_VkPhysicalDeviceExternalImageFormatInfo);
        break;
    case 1000071001:
        dump_text_pNext<const VkExternalImageFormatProperties>(reinterpret_cast<const VkExternalImageFormatProperties*>(object), settings, "VkExternalImageFormatProperties", indents, dump_text_VkExternalImageFormatProperties);
        break;
    case 1000071002:
        dump_text_pNext<const VkPhysicalDeviceExternalBufferInfo>(reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(object), settings, "VkPhysicalDeviceExternalBufferInfo", indents, dump_text_VkPhysicalDeviceExternalBufferInfo);
        break;
    case 1000071003:
        dump_text_pNext<const VkExternalBufferProperties>(reinterpret_cast<const VkExternalBufferProperties*>(object), settings, "VkExternalBufferProperties", indents, dump_text_VkExternalBufferProperties);
        break;
    case 1000071004:
        dump_text_pNext<const VkPhysicalDeviceIDProperties>(reinterpret_cast<const VkPhysicalDeviceIDProperties*>(object), settings, "VkPhysicalDeviceIDProperties", indents, dump_text_VkPhysicalDeviceIDProperties);
        break;
    case 1000072001:
        dump_text_pNext<const VkExternalMemoryImageCreateInfo>(reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(object), settings, "VkExternalMemoryImageCreateInfo", indents, dump_text_VkExternalMemoryImageCreateInfo);
        break;
    case 1000072000:
        dump_text_pNext<const VkExternalMemoryBufferCreateInfo>(reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(object), settings, "VkExternalMemoryBufferCreateInfo", indents, dump_text_VkExternalMemoryBufferCreateInfo);
        break;
    case 1000072002:
        dump_text_pNext<const VkExportMemoryAllocateInfo>(reinterpret_cast<const VkExportMemoryAllocateInfo*>(object), settings, "VkExportMemoryAllocateInfo", indents, dump_text_VkExportMemoryAllocateInfo);
        break;
    case 1000112000:
        dump_text_pNext<const VkPhysicalDeviceExternalFenceInfo>(reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(object), settings, "VkPhysicalDeviceExternalFenceInfo", indents, dump_text_VkPhysicalDeviceExternalFenceInfo);
        break;
    case 1000112001:
        dump_text_pNext<const VkExternalFenceProperties>(reinterpret_cast<const VkExternalFenceProperties*>(object), settings, "VkExternalFenceProperties", indents, dump_text_VkExternalFenceProperties);
        break;
    case 1000113000:
        dump_text_pNext<const VkExportFenceCreateInfo>(reinterpret_cast<const VkExportFenceCreateInfo*>(object), settings, "VkExportFenceCreateInfo", indents, dump_text_VkExportFenceCreateInfo);
        break;
    case 1000077000:
        dump_text_pNext<const VkExportSemaphoreCreateInfo>(reinterpret_cast<const VkExportSemaphoreCreateInfo*>(object), settings, "VkExportSemaphoreCreateInfo", indents, dump_text_VkExportSemaphoreCreateInfo);
        break;
    case 1000076000:
        dump_text_pNext<const VkPhysicalDeviceExternalSemaphoreInfo>(reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(object), settings, "VkPhysicalDeviceExternalSemaphoreInfo", indents, dump_text_VkPhysicalDeviceExternalSemaphoreInfo);
        break;
    case 1000076001:
        dump_text_pNext<const VkExternalSemaphoreProperties>(reinterpret_cast<const VkExternalSemaphoreProperties*>(object), settings, "VkExternalSemaphoreProperties", indents, dump_text_VkExternalSemaphoreProperties);
        break;
    case 1000168000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance3Properties>(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(object), settings, "VkPhysicalDeviceMaintenance3Properties", indents, dump_text_VkPhysicalDeviceMaintenance3Properties);
        break;
    case 1000168001:
        dump_text_pNext<const VkDescriptorSetLayoutSupport>(reinterpret_cast<const VkDescriptorSetLayoutSupport*>(object), settings, "VkDescriptorSetLayoutSupport", indents, dump_text_VkDescriptorSetLayoutSupport);
        break;
    case 1000063000:
        dump_text_pNext<const VkPhysicalDeviceShaderDrawParametersFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(object), settings, "VkPhysicalDeviceShaderDrawParametersFeatures", indents, dump_text_VkPhysicalDeviceShaderDrawParametersFeatures);
        break;
    case 49:
        dump_text_pNext<const VkPhysicalDeviceVulkan11Features>(reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(object), settings, "VkPhysicalDeviceVulkan11Features", indents, dump_text_VkPhysicalDeviceVulkan11Features);
        break;
    case 50:
        dump_text_pNext<const VkPhysicalDeviceVulkan11Properties>(reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(object), settings, "VkPhysicalDeviceVulkan11Properties", indents, dump_text_VkPhysicalDeviceVulkan11Properties);
        break;
    case 51:
        dump_text_pNext<const VkPhysicalDeviceVulkan12Features>(reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(object), settings, "VkPhysicalDeviceVulkan12Features", indents, dump_text_VkPhysicalDeviceVulkan12Features);
        break;
    case 52:
        dump_text_pNext<const VkPhysicalDeviceVulkan12Properties>(reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(object), settings, "VkPhysicalDeviceVulkan12Properties", indents, dump_text_VkPhysicalDeviceVulkan12Properties);
        break;
    case 1000147000:
        dump_text_pNext<const VkImageFormatListCreateInfo>(reinterpret_cast<const VkImageFormatListCreateInfo*>(object), settings, "VkImageFormatListCreateInfo", indents, dump_text_VkImageFormatListCreateInfo);
        break;
    case 1000109000:
        dump_text_pNext<const VkAttachmentDescription2>(reinterpret_cast<const VkAttachmentDescription2*>(object), settings, "VkAttachmentDescription2", indents, dump_text_VkAttachmentDescription2);
        break;
    case 1000109001:
        dump_text_pNext<const VkAttachmentReference2>(reinterpret_cast<const VkAttachmentReference2*>(object), settings, "VkAttachmentReference2", indents, dump_text_VkAttachmentReference2);
        break;
    case 1000109002:
        dump_text_pNext<const VkSubpassDescription2>(reinterpret_cast<const VkSubpassDescription2*>(object), settings, "VkSubpassDescription2", indents, dump_text_VkSubpassDescription2);
        break;
    case 1000109003:
        dump_text_pNext<const VkSubpassDependency2>(reinterpret_cast<const VkSubpassDependency2*>(object), settings, "VkSubpassDependency2", indents, dump_text_VkSubpassDependency2);
        break;
    case 1000109004:
        dump_text_pNext<const VkRenderPassCreateInfo2>(reinterpret_cast<const VkRenderPassCreateInfo2*>(object), settings, "VkRenderPassCreateInfo2", indents, dump_text_VkRenderPassCreateInfo2);
        break;
    case 1000109005:
        dump_text_pNext<const VkSubpassBeginInfo>(reinterpret_cast<const VkSubpassBeginInfo*>(object), settings, "VkSubpassBeginInfo", indents, dump_text_VkSubpassBeginInfo);
        break;
    case 1000109006:
        dump_text_pNext<const VkSubpassEndInfo>(reinterpret_cast<const VkSubpassEndInfo*>(object), settings, "VkSubpassEndInfo", indents, dump_text_VkSubpassEndInfo);
        break;
    case 1000177000:
        dump_text_pNext<const VkPhysicalDevice8BitStorageFeatures>(reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(object), settings, "VkPhysicalDevice8BitStorageFeatures", indents, dump_text_VkPhysicalDevice8BitStorageFeatures);
        break;
    case 1000196000:
        dump_text_pNext<const VkPhysicalDeviceDriverProperties>(reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(object), settings, "VkPhysicalDeviceDriverProperties", indents, dump_text_VkPhysicalDeviceDriverProperties);
        break;
    case 1000180000:
        dump_text_pNext<const VkPhysicalDeviceShaderAtomicInt64Features>(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(object), settings, "VkPhysicalDeviceShaderAtomicInt64Features", indents, dump_text_VkPhysicalDeviceShaderAtomicInt64Features);
        break;
    case 1000082000:
        dump_text_pNext<const VkPhysicalDeviceShaderFloat16Int8Features>(reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(object), settings, "VkPhysicalDeviceShaderFloat16Int8Features", indents, dump_text_VkPhysicalDeviceShaderFloat16Int8Features);
        break;
    case 1000197000:
        dump_text_pNext<const VkPhysicalDeviceFloatControlsProperties>(reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(object), settings, "VkPhysicalDeviceFloatControlsProperties", indents, dump_text_VkPhysicalDeviceFloatControlsProperties);
        break;
    case 1000161000:
        dump_text_pNext<const VkDescriptorSetLayoutBindingFlagsCreateInfo>(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(object), settings, "VkDescriptorSetLayoutBindingFlagsCreateInfo", indents, dump_text_VkDescriptorSetLayoutBindingFlagsCreateInfo);
        break;
    case 1000161001:
        dump_text_pNext<const VkPhysicalDeviceDescriptorIndexingFeatures>(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(object), settings, "VkPhysicalDeviceDescriptorIndexingFeatures", indents, dump_text_VkPhysicalDeviceDescriptorIndexingFeatures);
        break;
    case 1000161002:
        dump_text_pNext<const VkPhysicalDeviceDescriptorIndexingProperties>(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(object), settings, "VkPhysicalDeviceDescriptorIndexingProperties", indents, dump_text_VkPhysicalDeviceDescriptorIndexingProperties);
        break;
    case 1000161003:
        dump_text_pNext<const VkDescriptorSetVariableDescriptorCountAllocateInfo>(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(object), settings, "VkDescriptorSetVariableDescriptorCountAllocateInfo", indents, dump_text_VkDescriptorSetVariableDescriptorCountAllocateInfo);
        break;
    case 1000161004:
        dump_text_pNext<const VkDescriptorSetVariableDescriptorCountLayoutSupport>(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(object), settings, "VkDescriptorSetVariableDescriptorCountLayoutSupport", indents, dump_text_VkDescriptorSetVariableDescriptorCountLayoutSupport);
        break;
    case 1000199001:
        dump_text_pNext<const VkSubpassDescriptionDepthStencilResolve>(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(object), settings, "VkSubpassDescriptionDepthStencilResolve", indents, dump_text_VkSubpassDescriptionDepthStencilResolve);
        break;
    case 1000199000:
        dump_text_pNext<const VkPhysicalDeviceDepthStencilResolveProperties>(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(object), settings, "VkPhysicalDeviceDepthStencilResolveProperties", indents, dump_text_VkPhysicalDeviceDepthStencilResolveProperties);
        break;
    case 1000221000:
        dump_text_pNext<const VkPhysicalDeviceScalarBlockLayoutFeatures>(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(object), settings, "VkPhysicalDeviceScalarBlockLayoutFeatures", indents, dump_text_VkPhysicalDeviceScalarBlockLayoutFeatures);
        break;
    case 1000246000:
        dump_text_pNext<const VkImageStencilUsageCreateInfo>(reinterpret_cast<const VkImageStencilUsageCreateInfo*>(object), settings, "VkImageStencilUsageCreateInfo", indents, dump_text_VkImageStencilUsageCreateInfo);
        break;
    case 1000130001:
        dump_text_pNext<const VkSamplerReductionModeCreateInfo>(reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(object), settings, "VkSamplerReductionModeCreateInfo", indents, dump_text_VkSamplerReductionModeCreateInfo);
        break;
    case 1000130000:
        dump_text_pNext<const VkPhysicalDeviceSamplerFilterMinmaxProperties>(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(object), settings, "VkPhysicalDeviceSamplerFilterMinmaxProperties", indents, dump_text_VkPhysicalDeviceSamplerFilterMinmaxProperties);
        break;
    case 1000211000:
        dump_text_pNext<const VkPhysicalDeviceVulkanMemoryModelFeatures>(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(object), settings, "VkPhysicalDeviceVulkanMemoryModelFeatures", indents, dump_text_VkPhysicalDeviceVulkanMemoryModelFeatures);
        break;
    case 1000108000:
        dump_text_pNext<const VkPhysicalDeviceImagelessFramebufferFeatures>(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(object), settings, "VkPhysicalDeviceImagelessFramebufferFeatures", indents, dump_text_VkPhysicalDeviceImagelessFramebufferFeatures);
        break;
    case 1000108002:
        dump_text_pNext<const VkFramebufferAttachmentImageInfo>(reinterpret_cast<const VkFramebufferAttachmentImageInfo*>(object), settings, "VkFramebufferAttachmentImageInfo", indents, dump_text_VkFramebufferAttachmentImageInfo);
        break;
    case 1000108001:
        dump_text_pNext<const VkFramebufferAttachmentsCreateInfo>(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(object), settings, "VkFramebufferAttachmentsCreateInfo", indents, dump_text_VkFramebufferAttachmentsCreateInfo);
        break;
    case 1000108003:
        dump_text_pNext<const VkRenderPassAttachmentBeginInfo>(reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(object), settings, "VkRenderPassAttachmentBeginInfo", indents, dump_text_VkRenderPassAttachmentBeginInfo);
        break;
    case 1000253000:
        dump_text_pNext<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(object), settings, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", indents, dump_text_VkPhysicalDeviceUniformBufferStandardLayoutFeatures);
        break;
    case 1000175000:
        dump_text_pNext<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(object), settings, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", indents, dump_text_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures);
        break;
    case 1000241000:
        dump_text_pNext<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(object), settings, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", indents, dump_text_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures);
        break;
    case 1000241001:
        dump_text_pNext<const VkAttachmentReferenceStencilLayout>(reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(object), settings, "VkAttachmentReferenceStencilLayout", indents, dump_text_VkAttachmentReferenceStencilLayout);
        break;
    case 1000241002:
        dump_text_pNext<const VkAttachmentDescriptionStencilLayout>(reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(object), settings, "VkAttachmentDescriptionStencilLayout", indents, dump_text_VkAttachmentDescriptionStencilLayout);
        break;
    case 1000261000:
        dump_text_pNext<const VkPhysicalDeviceHostQueryResetFeatures>(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(object), settings, "VkPhysicalDeviceHostQueryResetFeatures", indents, dump_text_VkPhysicalDeviceHostQueryResetFeatures);
        break;
    case 1000207000:
        dump_text_pNext<const VkPhysicalDeviceTimelineSemaphoreFeatures>(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(object), settings, "VkPhysicalDeviceTimelineSemaphoreFeatures", indents, dump_text_VkPhysicalDeviceTimelineSemaphoreFeatures);
        break;
    case 1000207001:
        dump_text_pNext<const VkPhysicalDeviceTimelineSemaphoreProperties>(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(object), settings, "VkPhysicalDeviceTimelineSemaphoreProperties", indents, dump_text_VkPhysicalDeviceTimelineSemaphoreProperties);
        break;
    case 1000207002:
        dump_text_pNext<const VkSemaphoreTypeCreateInfo>(reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(object), settings, "VkSemaphoreTypeCreateInfo", indents, dump_text_VkSemaphoreTypeCreateInfo);
        break;
    case 1000207003:
        dump_text_pNext<const VkTimelineSemaphoreSubmitInfo>(reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(object), settings, "VkTimelineSemaphoreSubmitInfo", indents, dump_text_VkTimelineSemaphoreSubmitInfo);
        break;
    case 1000207004:
        dump_text_pNext<const VkSemaphoreWaitInfo>(reinterpret_cast<const VkSemaphoreWaitInfo*>(object), settings, "VkSemaphoreWaitInfo", indents, dump_text_VkSemaphoreWaitInfo);
        break;
    case 1000207005:
        dump_text_pNext<const VkSemaphoreSignalInfo>(reinterpret_cast<const VkSemaphoreSignalInfo*>(object), settings, "VkSemaphoreSignalInfo", indents, dump_text_VkSemaphoreSignalInfo);
        break;
    case 1000257000:
        dump_text_pNext<const VkPhysicalDeviceBufferDeviceAddressFeatures>(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(object), settings, "VkPhysicalDeviceBufferDeviceAddressFeatures", indents, dump_text_VkPhysicalDeviceBufferDeviceAddressFeatures);
        break;
    case 1000244001:
        dump_text_pNext<const VkBufferDeviceAddressInfo>(reinterpret_cast<const VkBufferDeviceAddressInfo*>(object), settings, "VkBufferDeviceAddressInfo", indents, dump_text_VkBufferDeviceAddressInfo);
        break;
    case 1000257002:
        dump_text_pNext<const VkBufferOpaqueCaptureAddressCreateInfo>(reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(object), settings, "VkBufferOpaqueCaptureAddressCreateInfo", indents, dump_text_VkBufferOpaqueCaptureAddressCreateInfo);
        break;
    case 1000257003:
        dump_text_pNext<const VkMemoryOpaqueCaptureAddressAllocateInfo>(reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(object), settings, "VkMemoryOpaqueCaptureAddressAllocateInfo", indents, dump_text_VkMemoryOpaqueCaptureAddressAllocateInfo);
        break;
    case 1000257004:
        dump_text_pNext<const VkDeviceMemoryOpaqueCaptureAddressInfo>(reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo*>(object), settings, "VkDeviceMemoryOpaqueCaptureAddressInfo", indents, dump_text_VkDeviceMemoryOpaqueCaptureAddressInfo);
        break;
    case 53:
        dump_text_pNext<const VkPhysicalDeviceVulkan13Features>(reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(object), settings, "VkPhysicalDeviceVulkan13Features", indents, dump_text_VkPhysicalDeviceVulkan13Features);
        break;
    case 54:
        dump_text_pNext<const VkPhysicalDeviceVulkan13Properties>(reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(object), settings, "VkPhysicalDeviceVulkan13Properties", indents, dump_text_VkPhysicalDeviceVulkan13Properties);
        break;
    case 1000192000:
        dump_text_pNext<const VkPipelineCreationFeedbackCreateInfo>(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(object), settings, "VkPipelineCreationFeedbackCreateInfo", indents, dump_text_VkPipelineCreationFeedbackCreateInfo);
        break;
    case 1000215000:
        dump_text_pNext<const VkPhysicalDeviceShaderTerminateInvocationFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(object), settings, "VkPhysicalDeviceShaderTerminateInvocationFeatures", indents, dump_text_VkPhysicalDeviceShaderTerminateInvocationFeatures);
        break;
    case 1000245000:
        dump_text_pNext<const VkPhysicalDeviceToolProperties>(reinterpret_cast<const VkPhysicalDeviceToolProperties*>(object), settings, "VkPhysicalDeviceToolProperties", indents, dump_text_VkPhysicalDeviceToolProperties);
        break;
    case 1000276000:
        dump_text_pNext<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(object), settings, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures", indents, dump_text_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures);
        break;
    case 1000295000:
        dump_text_pNext<const VkPhysicalDevicePrivateDataFeatures>(reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(object), settings, "VkPhysicalDevicePrivateDataFeatures", indents, dump_text_VkPhysicalDevicePrivateDataFeatures);
        break;
    case 1000295001:
        dump_text_pNext<const VkDevicePrivateDataCreateInfo>(reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(object), settings, "VkDevicePrivateDataCreateInfo", indents, dump_text_VkDevicePrivateDataCreateInfo);
        break;
    case 1000295002:
        dump_text_pNext<const VkPrivateDataSlotCreateInfo>(reinterpret_cast<const VkPrivateDataSlotCreateInfo*>(object), settings, "VkPrivateDataSlotCreateInfo", indents, dump_text_VkPrivateDataSlotCreateInfo);
        break;
    case 1000297000:
        dump_text_pNext<const VkPhysicalDevicePipelineCreationCacheControlFeatures>(reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(object), settings, "VkPhysicalDevicePipelineCreationCacheControlFeatures", indents, dump_text_VkPhysicalDevicePipelineCreationCacheControlFeatures);
        break;
    case 1000314000:
        dump_text_pNext<const VkMemoryBarrier2>(reinterpret_cast<const VkMemoryBarrier2*>(object), settings, "VkMemoryBarrier2", indents, dump_text_VkMemoryBarrier2);
        break;
    case 1000314001:
        dump_text_pNext<const VkBufferMemoryBarrier2>(reinterpret_cast<const VkBufferMemoryBarrier2*>(object), settings, "VkBufferMemoryBarrier2", indents, dump_text_VkBufferMemoryBarrier2);
        break;
    case 1000314002:
        dump_text_pNext<const VkImageMemoryBarrier2>(reinterpret_cast<const VkImageMemoryBarrier2*>(object), settings, "VkImageMemoryBarrier2", indents, dump_text_VkImageMemoryBarrier2);
        break;
    case 1000314003:
        dump_text_pNext<const VkDependencyInfo>(reinterpret_cast<const VkDependencyInfo*>(object), settings, "VkDependencyInfo", indents, dump_text_VkDependencyInfo);
        break;
    case 1000314005:
        dump_text_pNext<const VkSemaphoreSubmitInfo>(reinterpret_cast<const VkSemaphoreSubmitInfo*>(object), settings, "VkSemaphoreSubmitInfo", indents, dump_text_VkSemaphoreSubmitInfo);
        break;
    case 1000314006:
        dump_text_pNext<const VkCommandBufferSubmitInfo>(reinterpret_cast<const VkCommandBufferSubmitInfo*>(object), settings, "VkCommandBufferSubmitInfo", indents, dump_text_VkCommandBufferSubmitInfo);
        break;
    case 1000314004:
        dump_text_pNext<const VkSubmitInfo2>(reinterpret_cast<const VkSubmitInfo2*>(object), settings, "VkSubmitInfo2", indents, dump_text_VkSubmitInfo2);
        break;
    case 1000314007:
        dump_text_pNext<const VkPhysicalDeviceSynchronization2Features>(reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(object), settings, "VkPhysicalDeviceSynchronization2Features", indents, dump_text_VkPhysicalDeviceSynchronization2Features);
        break;
    case 1000325000:
        dump_text_pNext<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(object), settings, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", indents, dump_text_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures);
        break;
    case 1000335000:
        dump_text_pNext<const VkPhysicalDeviceImageRobustnessFeatures>(reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(object), settings, "VkPhysicalDeviceImageRobustnessFeatures", indents, dump_text_VkPhysicalDeviceImageRobustnessFeatures);
        break;
    case 1000337006:
        dump_text_pNext<const VkBufferCopy2>(reinterpret_cast<const VkBufferCopy2*>(object), settings, "VkBufferCopy2", indents, dump_text_VkBufferCopy2);
        break;
    case 1000337000:
        dump_text_pNext<const VkCopyBufferInfo2>(reinterpret_cast<const VkCopyBufferInfo2*>(object), settings, "VkCopyBufferInfo2", indents, dump_text_VkCopyBufferInfo2);
        break;
    case 1000337007:
        dump_text_pNext<const VkImageCopy2>(reinterpret_cast<const VkImageCopy2*>(object), settings, "VkImageCopy2", indents, dump_text_VkImageCopy2);
        break;
    case 1000337001:
        dump_text_pNext<const VkCopyImageInfo2>(reinterpret_cast<const VkCopyImageInfo2*>(object), settings, "VkCopyImageInfo2", indents, dump_text_VkCopyImageInfo2);
        break;
    case 1000337009:
        dump_text_pNext<const VkBufferImageCopy2>(reinterpret_cast<const VkBufferImageCopy2*>(object), settings, "VkBufferImageCopy2", indents, dump_text_VkBufferImageCopy2);
        break;
    case 1000337002:
        dump_text_pNext<const VkCopyBufferToImageInfo2>(reinterpret_cast<const VkCopyBufferToImageInfo2*>(object), settings, "VkCopyBufferToImageInfo2", indents, dump_text_VkCopyBufferToImageInfo2);
        break;
    case 1000337003:
        dump_text_pNext<const VkCopyImageToBufferInfo2>(reinterpret_cast<const VkCopyImageToBufferInfo2*>(object), settings, "VkCopyImageToBufferInfo2", indents, dump_text_VkCopyImageToBufferInfo2);
        break;
    case 1000337008:
        dump_text_pNext<const VkImageBlit2>(reinterpret_cast<const VkImageBlit2*>(object), settings, "VkImageBlit2", indents, dump_text_VkImageBlit2);
        break;
    case 1000337004:
        dump_text_pNext<const VkBlitImageInfo2>(reinterpret_cast<const VkBlitImageInfo2*>(object), settings, "VkBlitImageInfo2", indents, dump_text_VkBlitImageInfo2);
        break;
    case 1000337010:
        dump_text_pNext<const VkImageResolve2>(reinterpret_cast<const VkImageResolve2*>(object), settings, "VkImageResolve2", indents, dump_text_VkImageResolve2);
        break;
    case 1000337005:
        dump_text_pNext<const VkResolveImageInfo2>(reinterpret_cast<const VkResolveImageInfo2*>(object), settings, "VkResolveImageInfo2", indents, dump_text_VkResolveImageInfo2);
        break;
    case 1000225002:
        dump_text_pNext<const VkPhysicalDeviceSubgroupSizeControlFeatures>(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(object), settings, "VkPhysicalDeviceSubgroupSizeControlFeatures", indents, dump_text_VkPhysicalDeviceSubgroupSizeControlFeatures);
        break;
    case 1000225000:
        dump_text_pNext<const VkPhysicalDeviceSubgroupSizeControlProperties>(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(object), settings, "VkPhysicalDeviceSubgroupSizeControlProperties", indents, dump_text_VkPhysicalDeviceSubgroupSizeControlProperties);
        break;
    case 1000225001:
        dump_text_pNext<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>(reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(object), settings, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo", indents, dump_text_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo);
        break;
    case 1000138000:
        dump_text_pNext<const VkPhysicalDeviceInlineUniformBlockFeatures>(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(object), settings, "VkPhysicalDeviceInlineUniformBlockFeatures", indents, dump_text_VkPhysicalDeviceInlineUniformBlockFeatures);
        break;
    case 1000138001:
        dump_text_pNext<const VkPhysicalDeviceInlineUniformBlockProperties>(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(object), settings, "VkPhysicalDeviceInlineUniformBlockProperties", indents, dump_text_VkPhysicalDeviceInlineUniformBlockProperties);
        break;
    case 1000138002:
        dump_text_pNext<const VkWriteDescriptorSetInlineUniformBlock>(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(object), settings, "VkWriteDescriptorSetInlineUniformBlock", indents, dump_text_VkWriteDescriptorSetInlineUniformBlock);
        break;
    case 1000138003:
        dump_text_pNext<const VkDescriptorPoolInlineUniformBlockCreateInfo>(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(object), settings, "VkDescriptorPoolInlineUniformBlockCreateInfo", indents, dump_text_VkDescriptorPoolInlineUniformBlockCreateInfo);
        break;
    case 1000066000:
        dump_text_pNext<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures>(reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(object), settings, "VkPhysicalDeviceTextureCompressionASTCHDRFeatures", indents, dump_text_VkPhysicalDeviceTextureCompressionASTCHDRFeatures);
        break;
    case 1000044001:
        dump_text_pNext<const VkRenderingAttachmentInfo>(reinterpret_cast<const VkRenderingAttachmentInfo*>(object), settings, "VkRenderingAttachmentInfo", indents, dump_text_VkRenderingAttachmentInfo);
        break;
    case 1000044000:
        dump_text_pNext<const VkRenderingInfo>(reinterpret_cast<const VkRenderingInfo*>(object), settings, "VkRenderingInfo", indents, dump_text_VkRenderingInfo);
        break;
    case 1000044002:
        dump_text_pNext<const VkPipelineRenderingCreateInfo>(reinterpret_cast<const VkPipelineRenderingCreateInfo*>(object), settings, "VkPipelineRenderingCreateInfo", indents, dump_text_VkPipelineRenderingCreateInfo);
        break;
    case 1000044003:
        dump_text_pNext<const VkPhysicalDeviceDynamicRenderingFeatures>(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(object), settings, "VkPhysicalDeviceDynamicRenderingFeatures", indents, dump_text_VkPhysicalDeviceDynamicRenderingFeatures);
        break;
    case 1000044004:
        dump_text_pNext<const VkCommandBufferInheritanceRenderingInfo>(reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(object), settings, "VkCommandBufferInheritanceRenderingInfo", indents, dump_text_VkCommandBufferInheritanceRenderingInfo);
        break;
    case 1000280000:
        dump_text_pNext<const VkPhysicalDeviceShaderIntegerDotProductFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(object), settings, "VkPhysicalDeviceShaderIntegerDotProductFeatures", indents, dump_text_VkPhysicalDeviceShaderIntegerDotProductFeatures);
        break;
    case 1000280001:
        dump_text_pNext<const VkPhysicalDeviceShaderIntegerDotProductProperties>(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(object), settings, "VkPhysicalDeviceShaderIntegerDotProductProperties", indents, dump_text_VkPhysicalDeviceShaderIntegerDotProductProperties);
        break;
    case 1000281001:
        dump_text_pNext<const VkPhysicalDeviceTexelBufferAlignmentProperties>(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(object), settings, "VkPhysicalDeviceTexelBufferAlignmentProperties", indents, dump_text_VkPhysicalDeviceTexelBufferAlignmentProperties);
        break;
    case 1000360000:
        dump_text_pNext<const VkFormatProperties3>(reinterpret_cast<const VkFormatProperties3*>(object), settings, "VkFormatProperties3", indents, dump_text_VkFormatProperties3);
        break;
    case 1000413000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance4Features>(reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(object), settings, "VkPhysicalDeviceMaintenance4Features", indents, dump_text_VkPhysicalDeviceMaintenance4Features);
        break;
    case 1000413001:
        dump_text_pNext<const VkPhysicalDeviceMaintenance4Properties>(reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(object), settings, "VkPhysicalDeviceMaintenance4Properties", indents, dump_text_VkPhysicalDeviceMaintenance4Properties);
        break;
    case 1000413002:
        dump_text_pNext<const VkDeviceBufferMemoryRequirements>(reinterpret_cast<const VkDeviceBufferMemoryRequirements*>(object), settings, "VkDeviceBufferMemoryRequirements", indents, dump_text_VkDeviceBufferMemoryRequirements);
        break;
    case 1000413003:
        dump_text_pNext<const VkDeviceImageMemoryRequirements>(reinterpret_cast<const VkDeviceImageMemoryRequirements*>(object), settings, "VkDeviceImageMemoryRequirements", indents, dump_text_VkDeviceImageMemoryRequirements);
        break;
    case 55:
        dump_text_pNext<const VkPhysicalDeviceVulkan14Features>(reinterpret_cast<const VkPhysicalDeviceVulkan14Features*>(object), settings, "VkPhysicalDeviceVulkan14Features", indents, dump_text_VkPhysicalDeviceVulkan14Features);
        break;
    case 56:
        dump_text_pNext<const VkPhysicalDeviceVulkan14Properties>(reinterpret_cast<const VkPhysicalDeviceVulkan14Properties*>(object), settings, "VkPhysicalDeviceVulkan14Properties", indents, dump_text_VkPhysicalDeviceVulkan14Properties);
        break;
    case 1000174000:
        dump_text_pNext<const VkDeviceQueueGlobalPriorityCreateInfo>(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo*>(object), settings, "VkDeviceQueueGlobalPriorityCreateInfo", indents, dump_text_VkDeviceQueueGlobalPriorityCreateInfo);
        break;
    case 1000388000:
        dump_text_pNext<const VkPhysicalDeviceGlobalPriorityQueryFeatures>(reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures*>(object), settings, "VkPhysicalDeviceGlobalPriorityQueryFeatures", indents, dump_text_VkPhysicalDeviceGlobalPriorityQueryFeatures);
        break;
    case 1000388001:
        dump_text_pNext<const VkQueueFamilyGlobalPriorityProperties>(reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties*>(object), settings, "VkQueueFamilyGlobalPriorityProperties", indents, dump_text_VkQueueFamilyGlobalPriorityProperties);
        break;
    case 1000416000:
        dump_text_pNext<const VkPhysicalDeviceShaderSubgroupRotateFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures*>(object), settings, "VkPhysicalDeviceShaderSubgroupRotateFeatures", indents, dump_text_VkPhysicalDeviceShaderSubgroupRotateFeatures);
        break;
    case 1000528000:
        dump_text_pNext<const VkPhysicalDeviceShaderFloatControls2Features>(reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features*>(object), settings, "VkPhysicalDeviceShaderFloatControls2Features", indents, dump_text_VkPhysicalDeviceShaderFloatControls2Features);
        break;
    case 1000544000:
        dump_text_pNext<const VkPhysicalDeviceShaderExpectAssumeFeatures>(reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures*>(object), settings, "VkPhysicalDeviceShaderExpectAssumeFeatures", indents, dump_text_VkPhysicalDeviceShaderExpectAssumeFeatures);
        break;
    case 1000259000:
        dump_text_pNext<const VkPhysicalDeviceLineRasterizationFeatures>(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures*>(object), settings, "VkPhysicalDeviceLineRasterizationFeatures", indents, dump_text_VkPhysicalDeviceLineRasterizationFeatures);
        break;
    case 1000259002:
        dump_text_pNext<const VkPhysicalDeviceLineRasterizationProperties>(reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties*>(object), settings, "VkPhysicalDeviceLineRasterizationProperties", indents, dump_text_VkPhysicalDeviceLineRasterizationProperties);
        break;
    case 1000259001:
        dump_text_pNext<const VkPipelineRasterizationLineStateCreateInfo>(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo*>(object), settings, "VkPipelineRasterizationLineStateCreateInfo", indents, dump_text_VkPipelineRasterizationLineStateCreateInfo);
        break;
    case 1000525000:
        dump_text_pNext<const VkPhysicalDeviceVertexAttributeDivisorProperties>(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties*>(object), settings, "VkPhysicalDeviceVertexAttributeDivisorProperties", indents, dump_text_VkPhysicalDeviceVertexAttributeDivisorProperties);
        break;
    case 1000190001:
        dump_text_pNext<const VkPipelineVertexInputDivisorStateCreateInfo>(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo*>(object), settings, "VkPipelineVertexInputDivisorStateCreateInfo", indents, dump_text_VkPipelineVertexInputDivisorStateCreateInfo);
        break;
    case 1000190002:
        dump_text_pNext<const VkPhysicalDeviceVertexAttributeDivisorFeatures>(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures*>(object), settings, "VkPhysicalDeviceVertexAttributeDivisorFeatures", indents, dump_text_VkPhysicalDeviceVertexAttributeDivisorFeatures);
        break;
    case 1000265000:
        dump_text_pNext<const VkPhysicalDeviceIndexTypeUint8Features>(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features*>(object), settings, "VkPhysicalDeviceIndexTypeUint8Features", indents, dump_text_VkPhysicalDeviceIndexTypeUint8Features);
        break;
    case 1000271000:
        dump_text_pNext<const VkMemoryMapInfo>(reinterpret_cast<const VkMemoryMapInfo*>(object), settings, "VkMemoryMapInfo", indents, dump_text_VkMemoryMapInfo);
        break;
    case 1000271001:
        dump_text_pNext<const VkMemoryUnmapInfo>(reinterpret_cast<const VkMemoryUnmapInfo*>(object), settings, "VkMemoryUnmapInfo", indents, dump_text_VkMemoryUnmapInfo);
        break;
    case 1000470000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance5Features>(reinterpret_cast<const VkPhysicalDeviceMaintenance5Features*>(object), settings, "VkPhysicalDeviceMaintenance5Features", indents, dump_text_VkPhysicalDeviceMaintenance5Features);
        break;
    case 1000470001:
        dump_text_pNext<const VkPhysicalDeviceMaintenance5Properties>(reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties*>(object), settings, "VkPhysicalDeviceMaintenance5Properties", indents, dump_text_VkPhysicalDeviceMaintenance5Properties);
        break;
    case 1000470003:
        dump_text_pNext<const VkRenderingAreaInfo>(reinterpret_cast<const VkRenderingAreaInfo*>(object), settings, "VkRenderingAreaInfo", indents, dump_text_VkRenderingAreaInfo);
        break;
    case 1000338003:
        dump_text_pNext<const VkImageSubresource2>(reinterpret_cast<const VkImageSubresource2*>(object), settings, "VkImageSubresource2", indents, dump_text_VkImageSubresource2);
        break;
    case 1000470004:
        dump_text_pNext<const VkDeviceImageSubresourceInfo>(reinterpret_cast<const VkDeviceImageSubresourceInfo*>(object), settings, "VkDeviceImageSubresourceInfo", indents, dump_text_VkDeviceImageSubresourceInfo);
        break;
    case 1000338002:
        dump_text_pNext<const VkSubresourceLayout2>(reinterpret_cast<const VkSubresourceLayout2*>(object), settings, "VkSubresourceLayout2", indents, dump_text_VkSubresourceLayout2);
        break;
    case 1000470005:
        dump_text_pNext<const VkPipelineCreateFlags2CreateInfo>(reinterpret_cast<const VkPipelineCreateFlags2CreateInfo*>(object), settings, "VkPipelineCreateFlags2CreateInfo", indents, dump_text_VkPipelineCreateFlags2CreateInfo);
        break;
    case 1000470006:
        dump_text_pNext<const VkBufferUsageFlags2CreateInfo>(reinterpret_cast<const VkBufferUsageFlags2CreateInfo*>(object), settings, "VkBufferUsageFlags2CreateInfo", indents, dump_text_VkBufferUsageFlags2CreateInfo);
        break;
    case 1000080000:
        dump_text_pNext<const VkPhysicalDevicePushDescriptorProperties>(reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties*>(object), settings, "VkPhysicalDevicePushDescriptorProperties", indents, dump_text_VkPhysicalDevicePushDescriptorProperties);
        break;
    case 1000232000:
        dump_text_pNext<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures>(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(object), settings, "VkPhysicalDeviceDynamicRenderingLocalReadFeatures", indents, dump_text_VkPhysicalDeviceDynamicRenderingLocalReadFeatures);
        break;
    case 1000232001:
        dump_text_pNext<const VkRenderingAttachmentLocationInfo>(reinterpret_cast<const VkRenderingAttachmentLocationInfo*>(object), settings, "VkRenderingAttachmentLocationInfo", indents, dump_text_VkRenderingAttachmentLocationInfo);
        break;
    case 1000232002:
        dump_text_pNext<const VkRenderingInputAttachmentIndexInfo>(reinterpret_cast<const VkRenderingInputAttachmentIndexInfo*>(object), settings, "VkRenderingInputAttachmentIndexInfo", indents, dump_text_VkRenderingInputAttachmentIndexInfo);
        break;
    case 1000545000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance6Features>(reinterpret_cast<const VkPhysicalDeviceMaintenance6Features*>(object), settings, "VkPhysicalDeviceMaintenance6Features", indents, dump_text_VkPhysicalDeviceMaintenance6Features);
        break;
    case 1000545001:
        dump_text_pNext<const VkPhysicalDeviceMaintenance6Properties>(reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties*>(object), settings, "VkPhysicalDeviceMaintenance6Properties", indents, dump_text_VkPhysicalDeviceMaintenance6Properties);
        break;
    case 1000545002:
        dump_text_pNext<const VkBindMemoryStatus>(reinterpret_cast<const VkBindMemoryStatus*>(object), settings, "VkBindMemoryStatus", indents, dump_text_VkBindMemoryStatus);
        break;
    case 1000545003:
        dump_text_pNext<const VkBindDescriptorSetsInfo>(reinterpret_cast<const VkBindDescriptorSetsInfo*>(object), settings, "VkBindDescriptorSetsInfo", indents, dump_text_VkBindDescriptorSetsInfo);
        break;
    case 1000545004:
        dump_text_pNext<const VkPushConstantsInfo>(reinterpret_cast<const VkPushConstantsInfo*>(object), settings, "VkPushConstantsInfo", indents, dump_text_VkPushConstantsInfo);
        break;
    case 1000545005:
        dump_text_pNext<const VkPushDescriptorSetInfo>(reinterpret_cast<const VkPushDescriptorSetInfo*>(object), settings, "VkPushDescriptorSetInfo", indents, dump_text_VkPushDescriptorSetInfo);
        break;
    case 1000545006:
        dump_text_pNext<const VkPushDescriptorSetWithTemplateInfo>(reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo*>(object), settings, "VkPushDescriptorSetWithTemplateInfo", indents, dump_text_VkPushDescriptorSetWithTemplateInfo);
        break;
    case 1000466000:
        dump_text_pNext<const VkPhysicalDevicePipelineProtectedAccessFeatures>(reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures*>(object), settings, "VkPhysicalDevicePipelineProtectedAccessFeatures", indents, dump_text_VkPhysicalDevicePipelineProtectedAccessFeatures);
        break;
    case 1000068001:
        dump_text_pNext<const VkPhysicalDevicePipelineRobustnessFeatures>(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures*>(object), settings, "VkPhysicalDevicePipelineRobustnessFeatures", indents, dump_text_VkPhysicalDevicePipelineRobustnessFeatures);
        break;
    case 1000068002:
        dump_text_pNext<const VkPhysicalDevicePipelineRobustnessProperties>(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties*>(object), settings, "VkPhysicalDevicePipelineRobustnessProperties", indents, dump_text_VkPhysicalDevicePipelineRobustnessProperties);
        break;
    case 1000068000:
        dump_text_pNext<const VkPipelineRobustnessCreateInfo>(reinterpret_cast<const VkPipelineRobustnessCreateInfo*>(object), settings, "VkPipelineRobustnessCreateInfo", indents, dump_text_VkPipelineRobustnessCreateInfo);
        break;
    case 1000270000:
        dump_text_pNext<const VkPhysicalDeviceHostImageCopyFeatures>(reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures*>(object), settings, "VkPhysicalDeviceHostImageCopyFeatures", indents, dump_text_VkPhysicalDeviceHostImageCopyFeatures);
        break;
    case 1000270001:
        dump_text_pNext<const VkPhysicalDeviceHostImageCopyProperties>(reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties*>(object), settings, "VkPhysicalDeviceHostImageCopyProperties", indents, dump_text_VkPhysicalDeviceHostImageCopyProperties);
        break;
    case 1000270002:
        dump_text_pNext<const VkMemoryToImageCopy>(reinterpret_cast<const VkMemoryToImageCopy*>(object), settings, "VkMemoryToImageCopy", indents, dump_text_VkMemoryToImageCopy);
        break;
    case 1000270003:
        dump_text_pNext<const VkImageToMemoryCopy>(reinterpret_cast<const VkImageToMemoryCopy*>(object), settings, "VkImageToMemoryCopy", indents, dump_text_VkImageToMemoryCopy);
        break;
    case 1000270005:
        dump_text_pNext<const VkCopyMemoryToImageInfo>(reinterpret_cast<const VkCopyMemoryToImageInfo*>(object), settings, "VkCopyMemoryToImageInfo", indents, dump_text_VkCopyMemoryToImageInfo);
        break;
    case 1000270004:
        dump_text_pNext<const VkCopyImageToMemoryInfo>(reinterpret_cast<const VkCopyImageToMemoryInfo*>(object), settings, "VkCopyImageToMemoryInfo", indents, dump_text_VkCopyImageToMemoryInfo);
        break;
    case 1000270007:
        dump_text_pNext<const VkCopyImageToImageInfo>(reinterpret_cast<const VkCopyImageToImageInfo*>(object), settings, "VkCopyImageToImageInfo", indents, dump_text_VkCopyImageToImageInfo);
        break;
    case 1000270006:
        dump_text_pNext<const VkHostImageLayoutTransitionInfo>(reinterpret_cast<const VkHostImageLayoutTransitionInfo*>(object), settings, "VkHostImageLayoutTransitionInfo", indents, dump_text_VkHostImageLayoutTransitionInfo);
        break;
    case 1000270008:
        dump_text_pNext<const VkSubresourceHostMemcpySize>(reinterpret_cast<const VkSubresourceHostMemcpySize*>(object), settings, "VkSubresourceHostMemcpySize", indents, dump_text_VkSubresourceHostMemcpySize);
        break;
    case 1000270009:
        dump_text_pNext<const VkHostImageCopyDevicePerformanceQuery>(reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery*>(object), settings, "VkHostImageCopyDevicePerformanceQuery", indents, dump_text_VkHostImageCopyDevicePerformanceQuery);
        break;
    case 1000001000:
        dump_text_pNext<const VkSwapchainCreateInfoKHR>(reinterpret_cast<const VkSwapchainCreateInfoKHR*>(object), settings, "VkSwapchainCreateInfoKHR", indents, dump_text_VkSwapchainCreateInfoKHR);
        break;
    case 1000001001:
        dump_text_pNext<const VkPresentInfoKHR>(reinterpret_cast<const VkPresentInfoKHR*>(object), settings, "VkPresentInfoKHR", indents, dump_text_VkPresentInfoKHR);
        break;
    case 1000060008:
        dump_text_pNext<const VkImageSwapchainCreateInfoKHR>(reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(object), settings, "VkImageSwapchainCreateInfoKHR", indents, dump_text_VkImageSwapchainCreateInfoKHR);
        break;
    case 1000060009:
        dump_text_pNext<const VkBindImageMemorySwapchainInfoKHR>(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(object), settings, "VkBindImageMemorySwapchainInfoKHR", indents, dump_text_VkBindImageMemorySwapchainInfoKHR);
        break;
    case 1000060010:
        dump_text_pNext<const VkAcquireNextImageInfoKHR>(reinterpret_cast<const VkAcquireNextImageInfoKHR*>(object), settings, "VkAcquireNextImageInfoKHR", indents, dump_text_VkAcquireNextImageInfoKHR);
        break;
    case 1000060007:
        dump_text_pNext<const VkDeviceGroupPresentCapabilitiesKHR>(reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(object), settings, "VkDeviceGroupPresentCapabilitiesKHR", indents, dump_text_VkDeviceGroupPresentCapabilitiesKHR);
        break;
    case 1000060011:
        dump_text_pNext<const VkDeviceGroupPresentInfoKHR>(reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(object), settings, "VkDeviceGroupPresentInfoKHR", indents, dump_text_VkDeviceGroupPresentInfoKHR);
        break;
    case 1000060012:
        dump_text_pNext<const VkDeviceGroupSwapchainCreateInfoKHR>(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(object), settings, "VkDeviceGroupSwapchainCreateInfoKHR", indents, dump_text_VkDeviceGroupSwapchainCreateInfoKHR);
        break;
    case 1000002000:
        dump_text_pNext<const VkDisplayModeCreateInfoKHR>(reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(object), settings, "VkDisplayModeCreateInfoKHR", indents, dump_text_VkDisplayModeCreateInfoKHR);
        break;
    case 1000002001:
        dump_text_pNext<const VkDisplaySurfaceCreateInfoKHR>(reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(object), settings, "VkDisplaySurfaceCreateInfoKHR", indents, dump_text_VkDisplaySurfaceCreateInfoKHR);
        break;
    case 1000003000:
        dump_text_pNext<const VkDisplayPresentInfoKHR>(reinterpret_cast<const VkDisplayPresentInfoKHR*>(object), settings, "VkDisplayPresentInfoKHR", indents, dump_text_VkDisplayPresentInfoKHR);
        break;
#if defined(VK_USE_PLATFORM_XLIB_KHR)
    case 1000004000:
        dump_text_pNext<const VkXlibSurfaceCreateInfoKHR>(reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(object), settings, "VkXlibSurfaceCreateInfoKHR", indents, dump_text_VkXlibSurfaceCreateInfoKHR);
        break;
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
    case 1000005000:
        dump_text_pNext<const VkXcbSurfaceCreateInfoKHR>(reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(object), settings, "VkXcbSurfaceCreateInfoKHR", indents, dump_text_VkXcbSurfaceCreateInfoKHR);
        break;
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
    case 1000006000:
        dump_text_pNext<const VkWaylandSurfaceCreateInfoKHR>(reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(object), settings, "VkWaylandSurfaceCreateInfoKHR", indents, dump_text_VkWaylandSurfaceCreateInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000008000:
        dump_text_pNext<const VkAndroidSurfaceCreateInfoKHR>(reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(object), settings, "VkAndroidSurfaceCreateInfoKHR", indents, dump_text_VkAndroidSurfaceCreateInfoKHR);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000009000:
        dump_text_pNext<const VkWin32SurfaceCreateInfoKHR>(reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(object), settings, "VkWin32SurfaceCreateInfoKHR", indents, dump_text_VkWin32SurfaceCreateInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000011000:
        dump_text_pNext<const VkDebugReportCallbackCreateInfoEXT>(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(object), settings, "VkDebugReportCallbackCreateInfoEXT", indents, dump_text_VkDebugReportCallbackCreateInfoEXT);
        break;
    case 1000018000:
        dump_text_pNext<const VkPipelineRasterizationStateRasterizationOrderAMD>(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(object), settings, "VkPipelineRasterizationStateRasterizationOrderAMD", indents, dump_text_VkPipelineRasterizationStateRasterizationOrderAMD);
        break;
    case 1000022000:
        dump_text_pNext<const VkDebugMarkerObjectNameInfoEXT>(reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(object), settings, "VkDebugMarkerObjectNameInfoEXT", indents, dump_text_VkDebugMarkerObjectNameInfoEXT);
        break;
    case 1000022001:
        dump_text_pNext<const VkDebugMarkerObjectTagInfoEXT>(reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(object), settings, "VkDebugMarkerObjectTagInfoEXT", indents, dump_text_VkDebugMarkerObjectTagInfoEXT);
        break;
    case 1000022002:
        dump_text_pNext<const VkDebugMarkerMarkerInfoEXT>(reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(object), settings, "VkDebugMarkerMarkerInfoEXT", indents, dump_text_VkDebugMarkerMarkerInfoEXT);
        break;
    case 1000023016:
        dump_text_pNext<const VkQueueFamilyQueryResultStatusPropertiesKHR>(reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(object), settings, "VkQueueFamilyQueryResultStatusPropertiesKHR", indents, dump_text_VkQueueFamilyQueryResultStatusPropertiesKHR);
        break;
    case 1000023012:
        dump_text_pNext<const VkQueueFamilyVideoPropertiesKHR>(reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(object), settings, "VkQueueFamilyVideoPropertiesKHR", indents, dump_text_VkQueueFamilyVideoPropertiesKHR);
        break;
    case 1000023000:
        dump_text_pNext<const VkVideoProfileInfoKHR>(reinterpret_cast<const VkVideoProfileInfoKHR*>(object), settings, "VkVideoProfileInfoKHR", indents, dump_text_VkVideoProfileInfoKHR);
        break;
    case 1000023013:
        dump_text_pNext<const VkVideoProfileListInfoKHR>(reinterpret_cast<const VkVideoProfileListInfoKHR*>(object), settings, "VkVideoProfileListInfoKHR", indents, dump_text_VkVideoProfileListInfoKHR);
        break;
    case 1000023001:
        dump_text_pNext<const VkVideoCapabilitiesKHR>(reinterpret_cast<const VkVideoCapabilitiesKHR*>(object), settings, "VkVideoCapabilitiesKHR", indents, dump_text_VkVideoCapabilitiesKHR);
        break;
    case 1000023014:
        dump_text_pNext<const VkPhysicalDeviceVideoFormatInfoKHR>(reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR*>(object), settings, "VkPhysicalDeviceVideoFormatInfoKHR", indents, dump_text_VkPhysicalDeviceVideoFormatInfoKHR);
        break;
    case 1000023015:
        dump_text_pNext<const VkVideoFormatPropertiesKHR>(reinterpret_cast<const VkVideoFormatPropertiesKHR*>(object), settings, "VkVideoFormatPropertiesKHR", indents, dump_text_VkVideoFormatPropertiesKHR);
        break;
    case 1000023002:
        dump_text_pNext<const VkVideoPictureResourceInfoKHR>(reinterpret_cast<const VkVideoPictureResourceInfoKHR*>(object), settings, "VkVideoPictureResourceInfoKHR", indents, dump_text_VkVideoPictureResourceInfoKHR);
        break;
    case 1000023011:
        dump_text_pNext<const VkVideoReferenceSlotInfoKHR>(reinterpret_cast<const VkVideoReferenceSlotInfoKHR*>(object), settings, "VkVideoReferenceSlotInfoKHR", indents, dump_text_VkVideoReferenceSlotInfoKHR);
        break;
    case 1000023003:
        dump_text_pNext<const VkVideoSessionMemoryRequirementsKHR>(reinterpret_cast<const VkVideoSessionMemoryRequirementsKHR*>(object), settings, "VkVideoSessionMemoryRequirementsKHR", indents, dump_text_VkVideoSessionMemoryRequirementsKHR);
        break;
    case 1000023004:
        dump_text_pNext<const VkBindVideoSessionMemoryInfoKHR>(reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR*>(object), settings, "VkBindVideoSessionMemoryInfoKHR", indents, dump_text_VkBindVideoSessionMemoryInfoKHR);
        break;
    case 1000023005:
        dump_text_pNext<const VkVideoSessionCreateInfoKHR>(reinterpret_cast<const VkVideoSessionCreateInfoKHR*>(object), settings, "VkVideoSessionCreateInfoKHR", indents, dump_text_VkVideoSessionCreateInfoKHR);
        break;
    case 1000023006:
        dump_text_pNext<const VkVideoSessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR*>(object), settings, "VkVideoSessionParametersCreateInfoKHR", indents, dump_text_VkVideoSessionParametersCreateInfoKHR);
        break;
    case 1000023007:
        dump_text_pNext<const VkVideoSessionParametersUpdateInfoKHR>(reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR*>(object), settings, "VkVideoSessionParametersUpdateInfoKHR", indents, dump_text_VkVideoSessionParametersUpdateInfoKHR);
        break;
    case 1000023008:
        dump_text_pNext<const VkVideoBeginCodingInfoKHR>(reinterpret_cast<const VkVideoBeginCodingInfoKHR*>(object), settings, "VkVideoBeginCodingInfoKHR", indents, dump_text_VkVideoBeginCodingInfoKHR);
        break;
    case 1000023009:
        dump_text_pNext<const VkVideoEndCodingInfoKHR>(reinterpret_cast<const VkVideoEndCodingInfoKHR*>(object), settings, "VkVideoEndCodingInfoKHR", indents, dump_text_VkVideoEndCodingInfoKHR);
        break;
    case 1000023010:
        dump_text_pNext<const VkVideoCodingControlInfoKHR>(reinterpret_cast<const VkVideoCodingControlInfoKHR*>(object), settings, "VkVideoCodingControlInfoKHR", indents, dump_text_VkVideoCodingControlInfoKHR);
        break;
    case 1000024001:
        dump_text_pNext<const VkVideoDecodeCapabilitiesKHR>(reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(object), settings, "VkVideoDecodeCapabilitiesKHR", indents, dump_text_VkVideoDecodeCapabilitiesKHR);
        break;
    case 1000024002:
        dump_text_pNext<const VkVideoDecodeUsageInfoKHR>(reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(object), settings, "VkVideoDecodeUsageInfoKHR", indents, dump_text_VkVideoDecodeUsageInfoKHR);
        break;
    case 1000024000:
        dump_text_pNext<const VkVideoDecodeInfoKHR>(reinterpret_cast<const VkVideoDecodeInfoKHR*>(object), settings, "VkVideoDecodeInfoKHR", indents, dump_text_VkVideoDecodeInfoKHR);
        break;
    case 1000026000:
        dump_text_pNext<const VkDedicatedAllocationImageCreateInfoNV>(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(object), settings, "VkDedicatedAllocationImageCreateInfoNV", indents, dump_text_VkDedicatedAllocationImageCreateInfoNV);
        break;
    case 1000026001:
        dump_text_pNext<const VkDedicatedAllocationBufferCreateInfoNV>(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(object), settings, "VkDedicatedAllocationBufferCreateInfoNV", indents, dump_text_VkDedicatedAllocationBufferCreateInfoNV);
        break;
    case 1000026002:
        dump_text_pNext<const VkDedicatedAllocationMemoryAllocateInfoNV>(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(object), settings, "VkDedicatedAllocationMemoryAllocateInfoNV", indents, dump_text_VkDedicatedAllocationMemoryAllocateInfoNV);
        break;
    case 1000028000:
        dump_text_pNext<const VkPhysicalDeviceTransformFeedbackFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(object), settings, "VkPhysicalDeviceTransformFeedbackFeaturesEXT", indents, dump_text_VkPhysicalDeviceTransformFeedbackFeaturesEXT);
        break;
    case 1000028001:
        dump_text_pNext<const VkPhysicalDeviceTransformFeedbackPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(object), settings, "VkPhysicalDeviceTransformFeedbackPropertiesEXT", indents, dump_text_VkPhysicalDeviceTransformFeedbackPropertiesEXT);
        break;
    case 1000028002:
        dump_text_pNext<const VkPipelineRasterizationStateStreamCreateInfoEXT>(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(object), settings, "VkPipelineRasterizationStateStreamCreateInfoEXT", indents, dump_text_VkPipelineRasterizationStateStreamCreateInfoEXT);
        break;
    case 1000029000:
        dump_text_pNext<const VkCuModuleCreateInfoNVX>(reinterpret_cast<const VkCuModuleCreateInfoNVX*>(object), settings, "VkCuModuleCreateInfoNVX", indents, dump_text_VkCuModuleCreateInfoNVX);
        break;
    case 1000029004:
        dump_text_pNext<const VkCuModuleTexturingModeCreateInfoNVX>(reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX*>(object), settings, "VkCuModuleTexturingModeCreateInfoNVX", indents, dump_text_VkCuModuleTexturingModeCreateInfoNVX);
        break;
    case 1000029001:
        dump_text_pNext<const VkCuFunctionCreateInfoNVX>(reinterpret_cast<const VkCuFunctionCreateInfoNVX*>(object), settings, "VkCuFunctionCreateInfoNVX", indents, dump_text_VkCuFunctionCreateInfoNVX);
        break;
    case 1000029002:
        dump_text_pNext<const VkCuLaunchInfoNVX>(reinterpret_cast<const VkCuLaunchInfoNVX*>(object), settings, "VkCuLaunchInfoNVX", indents, dump_text_VkCuLaunchInfoNVX);
        break;
    case 1000030000:
        dump_text_pNext<const VkImageViewHandleInfoNVX>(reinterpret_cast<const VkImageViewHandleInfoNVX*>(object), settings, "VkImageViewHandleInfoNVX", indents, dump_text_VkImageViewHandleInfoNVX);
        break;
    case 1000030001:
        dump_text_pNext<const VkImageViewAddressPropertiesNVX>(reinterpret_cast<const VkImageViewAddressPropertiesNVX*>(object), settings, "VkImageViewAddressPropertiesNVX", indents, dump_text_VkImageViewAddressPropertiesNVX);
        break;
    case 1000038000:
        dump_text_pNext<const VkVideoEncodeH264CapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR*>(object), settings, "VkVideoEncodeH264CapabilitiesKHR", indents, dump_text_VkVideoEncodeH264CapabilitiesKHR);
        break;
    case 1000038011:
        dump_text_pNext<const VkVideoEncodeH264QualityLevelPropertiesKHR>(reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR*>(object), settings, "VkVideoEncodeH264QualityLevelPropertiesKHR", indents, dump_text_VkVideoEncodeH264QualityLevelPropertiesKHR);
        break;
    case 1000038010:
        dump_text_pNext<const VkVideoEncodeH264SessionCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR*>(object), settings, "VkVideoEncodeH264SessionCreateInfoKHR", indents, dump_text_VkVideoEncodeH264SessionCreateInfoKHR);
        break;
    case 1000038002:
        dump_text_pNext<const VkVideoEncodeH264SessionParametersAddInfoKHR>(reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR*>(object), settings, "VkVideoEncodeH264SessionParametersAddInfoKHR", indents, dump_text_VkVideoEncodeH264SessionParametersAddInfoKHR);
        break;
    case 1000038001:
        dump_text_pNext<const VkVideoEncodeH264SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR*>(object), settings, "VkVideoEncodeH264SessionParametersCreateInfoKHR", indents, dump_text_VkVideoEncodeH264SessionParametersCreateInfoKHR);
        break;
    case 1000038012:
        dump_text_pNext<const VkVideoEncodeH264SessionParametersGetInfoKHR>(reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR*>(object), settings, "VkVideoEncodeH264SessionParametersGetInfoKHR", indents, dump_text_VkVideoEncodeH264SessionParametersGetInfoKHR);
        break;
    case 1000038013:
        dump_text_pNext<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR>(reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(object), settings, "VkVideoEncodeH264SessionParametersFeedbackInfoKHR", indents, dump_text_VkVideoEncodeH264SessionParametersFeedbackInfoKHR);
        break;
    case 1000038005:
        dump_text_pNext<const VkVideoEncodeH264NaluSliceInfoKHR>(reinterpret_cast<const VkVideoEncodeH264NaluSliceInfoKHR*>(object), settings, "VkVideoEncodeH264NaluSliceInfoKHR", indents, dump_text_VkVideoEncodeH264NaluSliceInfoKHR);
        break;
    case 1000038003:
        dump_text_pNext<const VkVideoEncodeH264PictureInfoKHR>(reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR*>(object), settings, "VkVideoEncodeH264PictureInfoKHR", indents, dump_text_VkVideoEncodeH264PictureInfoKHR);
        break;
    case 1000038004:
        dump_text_pNext<const VkVideoEncodeH264DpbSlotInfoKHR>(reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR*>(object), settings, "VkVideoEncodeH264DpbSlotInfoKHR", indents, dump_text_VkVideoEncodeH264DpbSlotInfoKHR);
        break;
    case 1000038007:
        dump_text_pNext<const VkVideoEncodeH264ProfileInfoKHR>(reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR*>(object), settings, "VkVideoEncodeH264ProfileInfoKHR", indents, dump_text_VkVideoEncodeH264ProfileInfoKHR);
        break;
    case 1000038008:
        dump_text_pNext<const VkVideoEncodeH264RateControlInfoKHR>(reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR*>(object), settings, "VkVideoEncodeH264RateControlInfoKHR", indents, dump_text_VkVideoEncodeH264RateControlInfoKHR);
        break;
    case 1000038009:
        dump_text_pNext<const VkVideoEncodeH264RateControlLayerInfoKHR>(reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR*>(object), settings, "VkVideoEncodeH264RateControlLayerInfoKHR", indents, dump_text_VkVideoEncodeH264RateControlLayerInfoKHR);
        break;
    case 1000038006:
        dump_text_pNext<const VkVideoEncodeH264GopRemainingFrameInfoKHR>(reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR*>(object), settings, "VkVideoEncodeH264GopRemainingFrameInfoKHR", indents, dump_text_VkVideoEncodeH264GopRemainingFrameInfoKHR);
        break;
    case 1000039000:
        dump_text_pNext<const VkVideoEncodeH265CapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR*>(object), settings, "VkVideoEncodeH265CapabilitiesKHR", indents, dump_text_VkVideoEncodeH265CapabilitiesKHR);
        break;
    case 1000039011:
        dump_text_pNext<const VkVideoEncodeH265SessionCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR*>(object), settings, "VkVideoEncodeH265SessionCreateInfoKHR", indents, dump_text_VkVideoEncodeH265SessionCreateInfoKHR);
        break;
    case 1000039012:
        dump_text_pNext<const VkVideoEncodeH265QualityLevelPropertiesKHR>(reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR*>(object), settings, "VkVideoEncodeH265QualityLevelPropertiesKHR", indents, dump_text_VkVideoEncodeH265QualityLevelPropertiesKHR);
        break;
    case 1000039002:
        dump_text_pNext<const VkVideoEncodeH265SessionParametersAddInfoKHR>(reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR*>(object), settings, "VkVideoEncodeH265SessionParametersAddInfoKHR", indents, dump_text_VkVideoEncodeH265SessionParametersAddInfoKHR);
        break;
    case 1000039001:
        dump_text_pNext<const VkVideoEncodeH265SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR*>(object), settings, "VkVideoEncodeH265SessionParametersCreateInfoKHR", indents, dump_text_VkVideoEncodeH265SessionParametersCreateInfoKHR);
        break;
    case 1000039013:
        dump_text_pNext<const VkVideoEncodeH265SessionParametersGetInfoKHR>(reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR*>(object), settings, "VkVideoEncodeH265SessionParametersGetInfoKHR", indents, dump_text_VkVideoEncodeH265SessionParametersGetInfoKHR);
        break;
    case 1000039014:
        dump_text_pNext<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR>(reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(object), settings, "VkVideoEncodeH265SessionParametersFeedbackInfoKHR", indents, dump_text_VkVideoEncodeH265SessionParametersFeedbackInfoKHR);
        break;
    case 1000039005:
        dump_text_pNext<const VkVideoEncodeH265NaluSliceSegmentInfoKHR>(reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(object), settings, "VkVideoEncodeH265NaluSliceSegmentInfoKHR", indents, dump_text_VkVideoEncodeH265NaluSliceSegmentInfoKHR);
        break;
    case 1000039003:
        dump_text_pNext<const VkVideoEncodeH265PictureInfoKHR>(reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR*>(object), settings, "VkVideoEncodeH265PictureInfoKHR", indents, dump_text_VkVideoEncodeH265PictureInfoKHR);
        break;
    case 1000039004:
        dump_text_pNext<const VkVideoEncodeH265DpbSlotInfoKHR>(reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR*>(object), settings, "VkVideoEncodeH265DpbSlotInfoKHR", indents, dump_text_VkVideoEncodeH265DpbSlotInfoKHR);
        break;
    case 1000039007:
        dump_text_pNext<const VkVideoEncodeH265ProfileInfoKHR>(reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR*>(object), settings, "VkVideoEncodeH265ProfileInfoKHR", indents, dump_text_VkVideoEncodeH265ProfileInfoKHR);
        break;
    case 1000039009:
        dump_text_pNext<const VkVideoEncodeH265RateControlInfoKHR>(reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR*>(object), settings, "VkVideoEncodeH265RateControlInfoKHR", indents, dump_text_VkVideoEncodeH265RateControlInfoKHR);
        break;
    case 1000039010:
        dump_text_pNext<const VkVideoEncodeH265RateControlLayerInfoKHR>(reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR*>(object), settings, "VkVideoEncodeH265RateControlLayerInfoKHR", indents, dump_text_VkVideoEncodeH265RateControlLayerInfoKHR);
        break;
    case 1000039006:
        dump_text_pNext<const VkVideoEncodeH265GopRemainingFrameInfoKHR>(reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR*>(object), settings, "VkVideoEncodeH265GopRemainingFrameInfoKHR", indents, dump_text_VkVideoEncodeH265GopRemainingFrameInfoKHR);
        break;
    case 1000040003:
        dump_text_pNext<const VkVideoDecodeH264ProfileInfoKHR>(reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(object), settings, "VkVideoDecodeH264ProfileInfoKHR", indents, dump_text_VkVideoDecodeH264ProfileInfoKHR);
        break;
    case 1000040000:
        dump_text_pNext<const VkVideoDecodeH264CapabilitiesKHR>(reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(object), settings, "VkVideoDecodeH264CapabilitiesKHR", indents, dump_text_VkVideoDecodeH264CapabilitiesKHR);
        break;
    case 1000040005:
        dump_text_pNext<const VkVideoDecodeH264SessionParametersAddInfoKHR>(reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(object), settings, "VkVideoDecodeH264SessionParametersAddInfoKHR", indents, dump_text_VkVideoDecodeH264SessionParametersAddInfoKHR);
        break;
    case 1000040004:
        dump_text_pNext<const VkVideoDecodeH264SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(object), settings, "VkVideoDecodeH264SessionParametersCreateInfoKHR", indents, dump_text_VkVideoDecodeH264SessionParametersCreateInfoKHR);
        break;
    case 1000040001:
        dump_text_pNext<const VkVideoDecodeH264PictureInfoKHR>(reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(object), settings, "VkVideoDecodeH264PictureInfoKHR", indents, dump_text_VkVideoDecodeH264PictureInfoKHR);
        break;
    case 1000040006:
        dump_text_pNext<const VkVideoDecodeH264DpbSlotInfoKHR>(reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(object), settings, "VkVideoDecodeH264DpbSlotInfoKHR", indents, dump_text_VkVideoDecodeH264DpbSlotInfoKHR);
        break;
    case 1000041000:
        dump_text_pNext<const VkTextureLODGatherFormatPropertiesAMD>(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(object), settings, "VkTextureLODGatherFormatPropertiesAMD", indents, dump_text_VkTextureLODGatherFormatPropertiesAMD);
        break;
#if defined(VK_USE_PLATFORM_GGP)
    case 1000049000:
        dump_text_pNext<const VkStreamDescriptorSurfaceCreateInfoGGP>(reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP*>(object), settings, "VkStreamDescriptorSurfaceCreateInfoGGP", indents, dump_text_VkStreamDescriptorSurfaceCreateInfoGGP);
        break;
#endif // VK_USE_PLATFORM_GGP
    case 1000050000:
        dump_text_pNext<const VkPhysicalDeviceCornerSampledImageFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(object), settings, "VkPhysicalDeviceCornerSampledImageFeaturesNV", indents, dump_text_VkPhysicalDeviceCornerSampledImageFeaturesNV);
        break;
    case 1000056000:
        dump_text_pNext<const VkExternalMemoryImageCreateInfoNV>(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(object), settings, "VkExternalMemoryImageCreateInfoNV", indents, dump_text_VkExternalMemoryImageCreateInfoNV);
        break;
    case 1000056001:
        dump_text_pNext<const VkExportMemoryAllocateInfoNV>(reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(object), settings, "VkExportMemoryAllocateInfoNV", indents, dump_text_VkExportMemoryAllocateInfoNV);
        break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000057000:
        dump_text_pNext<const VkImportMemoryWin32HandleInfoNV>(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(object), settings, "VkImportMemoryWin32HandleInfoNV", indents, dump_text_VkImportMemoryWin32HandleInfoNV);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000057001:
        dump_text_pNext<const VkExportMemoryWin32HandleInfoNV>(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(object), settings, "VkExportMemoryWin32HandleInfoNV", indents, dump_text_VkExportMemoryWin32HandleInfoNV);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000058000:
        dump_text_pNext<const VkWin32KeyedMutexAcquireReleaseInfoNV>(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(object), settings, "VkWin32KeyedMutexAcquireReleaseInfoNV", indents, dump_text_VkWin32KeyedMutexAcquireReleaseInfoNV);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000061000:
        dump_text_pNext<const VkValidationFlagsEXT>(reinterpret_cast<const VkValidationFlagsEXT*>(object), settings, "VkValidationFlagsEXT", indents, dump_text_VkValidationFlagsEXT);
        break;
#if defined(VK_USE_PLATFORM_VI_NN)
    case 1000062000:
        dump_text_pNext<const VkViSurfaceCreateInfoNN>(reinterpret_cast<const VkViSurfaceCreateInfoNN*>(object), settings, "VkViSurfaceCreateInfoNN", indents, dump_text_VkViSurfaceCreateInfoNN);
        break;
#endif // VK_USE_PLATFORM_VI_NN
    case 1000067000:
        dump_text_pNext<const VkImageViewASTCDecodeModeEXT>(reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(object), settings, "VkImageViewASTCDecodeModeEXT", indents, dump_text_VkImageViewASTCDecodeModeEXT);
        break;
    case 1000067001:
        dump_text_pNext<const VkPhysicalDeviceASTCDecodeFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(object), settings, "VkPhysicalDeviceASTCDecodeFeaturesEXT", indents, dump_text_VkPhysicalDeviceASTCDecodeFeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000073000:
        dump_text_pNext<const VkImportMemoryWin32HandleInfoKHR>(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(object), settings, "VkImportMemoryWin32HandleInfoKHR", indents, dump_text_VkImportMemoryWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000073001:
        dump_text_pNext<const VkExportMemoryWin32HandleInfoKHR>(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(object), settings, "VkExportMemoryWin32HandleInfoKHR", indents, dump_text_VkExportMemoryWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000073002:
        dump_text_pNext<const VkMemoryWin32HandlePropertiesKHR>(reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(object), settings, "VkMemoryWin32HandlePropertiesKHR", indents, dump_text_VkMemoryWin32HandlePropertiesKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000073003:
        dump_text_pNext<const VkMemoryGetWin32HandleInfoKHR>(reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(object), settings, "VkMemoryGetWin32HandleInfoKHR", indents, dump_text_VkMemoryGetWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000074000:
        dump_text_pNext<const VkImportMemoryFdInfoKHR>(reinterpret_cast<const VkImportMemoryFdInfoKHR*>(object), settings, "VkImportMemoryFdInfoKHR", indents, dump_text_VkImportMemoryFdInfoKHR);
        break;
    case 1000074001:
        dump_text_pNext<const VkMemoryFdPropertiesKHR>(reinterpret_cast<const VkMemoryFdPropertiesKHR*>(object), settings, "VkMemoryFdPropertiesKHR", indents, dump_text_VkMemoryFdPropertiesKHR);
        break;
    case 1000074002:
        dump_text_pNext<const VkMemoryGetFdInfoKHR>(reinterpret_cast<const VkMemoryGetFdInfoKHR*>(object), settings, "VkMemoryGetFdInfoKHR", indents, dump_text_VkMemoryGetFdInfoKHR);
        break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000075000:
        dump_text_pNext<const VkWin32KeyedMutexAcquireReleaseInfoKHR>(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(object), settings, "VkWin32KeyedMutexAcquireReleaseInfoKHR", indents, dump_text_VkWin32KeyedMutexAcquireReleaseInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000078000:
        dump_text_pNext<const VkImportSemaphoreWin32HandleInfoKHR>(reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(object), settings, "VkImportSemaphoreWin32HandleInfoKHR", indents, dump_text_VkImportSemaphoreWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000078001:
        dump_text_pNext<const VkExportSemaphoreWin32HandleInfoKHR>(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(object), settings, "VkExportSemaphoreWin32HandleInfoKHR", indents, dump_text_VkExportSemaphoreWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000078002:
        dump_text_pNext<const VkD3D12FenceSubmitInfoKHR>(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(object), settings, "VkD3D12FenceSubmitInfoKHR", indents, dump_text_VkD3D12FenceSubmitInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000078003:
        dump_text_pNext<const VkSemaphoreGetWin32HandleInfoKHR>(reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(object), settings, "VkSemaphoreGetWin32HandleInfoKHR", indents, dump_text_VkSemaphoreGetWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000079000:
        dump_text_pNext<const VkImportSemaphoreFdInfoKHR>(reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(object), settings, "VkImportSemaphoreFdInfoKHR", indents, dump_text_VkImportSemaphoreFdInfoKHR);
        break;
    case 1000079001:
        dump_text_pNext<const VkSemaphoreGetFdInfoKHR>(reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(object), settings, "VkSemaphoreGetFdInfoKHR", indents, dump_text_VkSemaphoreGetFdInfoKHR);
        break;
    case 1000081002:
        dump_text_pNext<const VkConditionalRenderingBeginInfoEXT>(reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(object), settings, "VkConditionalRenderingBeginInfoEXT", indents, dump_text_VkConditionalRenderingBeginInfoEXT);
        break;
    case 1000081001:
        dump_text_pNext<const VkPhysicalDeviceConditionalRenderingFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(object), settings, "VkPhysicalDeviceConditionalRenderingFeaturesEXT", indents, dump_text_VkPhysicalDeviceConditionalRenderingFeaturesEXT);
        break;
    case 1000081000:
        dump_text_pNext<const VkCommandBufferInheritanceConditionalRenderingInfoEXT>(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(object), settings, "VkCommandBufferInheritanceConditionalRenderingInfoEXT", indents, dump_text_VkCommandBufferInheritanceConditionalRenderingInfoEXT);
        break;
    case 1000084000:
        dump_text_pNext<const VkPresentRegionsKHR>(reinterpret_cast<const VkPresentRegionsKHR*>(object), settings, "VkPresentRegionsKHR", indents, dump_text_VkPresentRegionsKHR);
        break;
    case 1000087000:
        dump_text_pNext<const VkPipelineViewportWScalingStateCreateInfoNV>(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(object), settings, "VkPipelineViewportWScalingStateCreateInfoNV", indents, dump_text_VkPipelineViewportWScalingStateCreateInfoNV);
        break;
    case 1000090000:
        dump_text_pNext<const VkSurfaceCapabilities2EXT>(reinterpret_cast<const VkSurfaceCapabilities2EXT*>(object), settings, "VkSurfaceCapabilities2EXT", indents, dump_text_VkSurfaceCapabilities2EXT);
        break;
    case 1000091000:
        dump_text_pNext<const VkDisplayPowerInfoEXT>(reinterpret_cast<const VkDisplayPowerInfoEXT*>(object), settings, "VkDisplayPowerInfoEXT", indents, dump_text_VkDisplayPowerInfoEXT);
        break;
    case 1000091001:
        dump_text_pNext<const VkDeviceEventInfoEXT>(reinterpret_cast<const VkDeviceEventInfoEXT*>(object), settings, "VkDeviceEventInfoEXT", indents, dump_text_VkDeviceEventInfoEXT);
        break;
    case 1000091002:
        dump_text_pNext<const VkDisplayEventInfoEXT>(reinterpret_cast<const VkDisplayEventInfoEXT*>(object), settings, "VkDisplayEventInfoEXT", indents, dump_text_VkDisplayEventInfoEXT);
        break;
    case 1000091003:
        dump_text_pNext<const VkSwapchainCounterCreateInfoEXT>(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(object), settings, "VkSwapchainCounterCreateInfoEXT", indents, dump_text_VkSwapchainCounterCreateInfoEXT);
        break;
    case 1000092000:
        dump_text_pNext<const VkPresentTimesInfoGOOGLE>(reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(object), settings, "VkPresentTimesInfoGOOGLE", indents, dump_text_VkPresentTimesInfoGOOGLE);
        break;
    case 1000097000:
        dump_text_pNext<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(object), settings, "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX", indents, dump_text_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
        break;
    case 1000044009:
        dump_text_pNext<const VkMultiviewPerViewAttributesInfoNVX>(reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(object), settings, "VkMultiviewPerViewAttributesInfoNVX", indents, dump_text_VkMultiviewPerViewAttributesInfoNVX);
        break;
    case 1000098000:
        dump_text_pNext<const VkPipelineViewportSwizzleStateCreateInfoNV>(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(object), settings, "VkPipelineViewportSwizzleStateCreateInfoNV", indents, dump_text_VkPipelineViewportSwizzleStateCreateInfoNV);
        break;
    case 1000099000:
        dump_text_pNext<const VkPhysicalDeviceDiscardRectanglePropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(object), settings, "VkPhysicalDeviceDiscardRectanglePropertiesEXT", indents, dump_text_VkPhysicalDeviceDiscardRectanglePropertiesEXT);
        break;
    case 1000099001:
        dump_text_pNext<const VkPipelineDiscardRectangleStateCreateInfoEXT>(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(object), settings, "VkPipelineDiscardRectangleStateCreateInfoEXT", indents, dump_text_VkPipelineDiscardRectangleStateCreateInfoEXT);
        break;
    case 1000101000:
        dump_text_pNext<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(object), settings, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT", indents, dump_text_VkPhysicalDeviceConservativeRasterizationPropertiesEXT);
        break;
    case 1000101001:
        dump_text_pNext<const VkPipelineRasterizationConservativeStateCreateInfoEXT>(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(object), settings, "VkPipelineRasterizationConservativeStateCreateInfoEXT", indents, dump_text_VkPipelineRasterizationConservativeStateCreateInfoEXT);
        break;
    case 1000102000:
        dump_text_pNext<const VkPhysicalDeviceDepthClipEnableFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(object), settings, "VkPhysicalDeviceDepthClipEnableFeaturesEXT", indents, dump_text_VkPhysicalDeviceDepthClipEnableFeaturesEXT);
        break;
    case 1000102001:
        dump_text_pNext<const VkPipelineRasterizationDepthClipStateCreateInfoEXT>(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(object), settings, "VkPipelineRasterizationDepthClipStateCreateInfoEXT", indents, dump_text_VkPipelineRasterizationDepthClipStateCreateInfoEXT);
        break;
    case 1000105000:
        dump_text_pNext<const VkHdrMetadataEXT>(reinterpret_cast<const VkHdrMetadataEXT*>(object), settings, "VkHdrMetadataEXT", indents, dump_text_VkHdrMetadataEXT);
        break;
    case 1000110000:
        dump_text_pNext<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG>(reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(object), settings, "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG", indents, dump_text_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG);
        break;
    case 1000111000:
        dump_text_pNext<const VkSharedPresentSurfaceCapabilitiesKHR>(reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(object), settings, "VkSharedPresentSurfaceCapabilitiesKHR", indents, dump_text_VkSharedPresentSurfaceCapabilitiesKHR);
        break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000114000:
        dump_text_pNext<const VkImportFenceWin32HandleInfoKHR>(reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(object), settings, "VkImportFenceWin32HandleInfoKHR", indents, dump_text_VkImportFenceWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000114001:
        dump_text_pNext<const VkExportFenceWin32HandleInfoKHR>(reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(object), settings, "VkExportFenceWin32HandleInfoKHR", indents, dump_text_VkExportFenceWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000114002:
        dump_text_pNext<const VkFenceGetWin32HandleInfoKHR>(reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(object), settings, "VkFenceGetWin32HandleInfoKHR", indents, dump_text_VkFenceGetWin32HandleInfoKHR);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000115000:
        dump_text_pNext<const VkImportFenceFdInfoKHR>(reinterpret_cast<const VkImportFenceFdInfoKHR*>(object), settings, "VkImportFenceFdInfoKHR", indents, dump_text_VkImportFenceFdInfoKHR);
        break;
    case 1000115001:
        dump_text_pNext<const VkFenceGetFdInfoKHR>(reinterpret_cast<const VkFenceGetFdInfoKHR*>(object), settings, "VkFenceGetFdInfoKHR", indents, dump_text_VkFenceGetFdInfoKHR);
        break;
    case 1000116000:
        dump_text_pNext<const VkPhysicalDevicePerformanceQueryFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(object), settings, "VkPhysicalDevicePerformanceQueryFeaturesKHR", indents, dump_text_VkPhysicalDevicePerformanceQueryFeaturesKHR);
        break;
    case 1000116001:
        dump_text_pNext<const VkPhysicalDevicePerformanceQueryPropertiesKHR>(reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(object), settings, "VkPhysicalDevicePerformanceQueryPropertiesKHR", indents, dump_text_VkPhysicalDevicePerformanceQueryPropertiesKHR);
        break;
    case 1000116005:
        dump_text_pNext<const VkPerformanceCounterKHR>(reinterpret_cast<const VkPerformanceCounterKHR*>(object), settings, "VkPerformanceCounterKHR", indents, dump_text_VkPerformanceCounterKHR);
        break;
    case 1000116006:
        dump_text_pNext<const VkPerformanceCounterDescriptionKHR>(reinterpret_cast<const VkPerformanceCounterDescriptionKHR*>(object), settings, "VkPerformanceCounterDescriptionKHR", indents, dump_text_VkPerformanceCounterDescriptionKHR);
        break;
    case 1000116002:
        dump_text_pNext<const VkQueryPoolPerformanceCreateInfoKHR>(reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(object), settings, "VkQueryPoolPerformanceCreateInfoKHR", indents, dump_text_VkQueryPoolPerformanceCreateInfoKHR);
        break;
    case 1000116004:
        dump_text_pNext<const VkAcquireProfilingLockInfoKHR>(reinterpret_cast<const VkAcquireProfilingLockInfoKHR*>(object), settings, "VkAcquireProfilingLockInfoKHR", indents, dump_text_VkAcquireProfilingLockInfoKHR);
        break;
    case 1000116003:
        dump_text_pNext<const VkPerformanceQuerySubmitInfoKHR>(reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(object), settings, "VkPerformanceQuerySubmitInfoKHR", indents, dump_text_VkPerformanceQuerySubmitInfoKHR);
        break;
    case 1000119000:
        dump_text_pNext<const VkPhysicalDeviceSurfaceInfo2KHR>(reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(object), settings, "VkPhysicalDeviceSurfaceInfo2KHR", indents, dump_text_VkPhysicalDeviceSurfaceInfo2KHR);
        break;
    case 1000119001:
        dump_text_pNext<const VkSurfaceCapabilities2KHR>(reinterpret_cast<const VkSurfaceCapabilities2KHR*>(object), settings, "VkSurfaceCapabilities2KHR", indents, dump_text_VkSurfaceCapabilities2KHR);
        break;
    case 1000119002:
        dump_text_pNext<const VkSurfaceFormat2KHR>(reinterpret_cast<const VkSurfaceFormat2KHR*>(object), settings, "VkSurfaceFormat2KHR", indents, dump_text_VkSurfaceFormat2KHR);
        break;
    case 1000121000:
        dump_text_pNext<const VkDisplayProperties2KHR>(reinterpret_cast<const VkDisplayProperties2KHR*>(object), settings, "VkDisplayProperties2KHR", indents, dump_text_VkDisplayProperties2KHR);
        break;
    case 1000121001:
        dump_text_pNext<const VkDisplayPlaneProperties2KHR>(reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(object), settings, "VkDisplayPlaneProperties2KHR", indents, dump_text_VkDisplayPlaneProperties2KHR);
        break;
    case 1000121002:
        dump_text_pNext<const VkDisplayModeProperties2KHR>(reinterpret_cast<const VkDisplayModeProperties2KHR*>(object), settings, "VkDisplayModeProperties2KHR", indents, dump_text_VkDisplayModeProperties2KHR);
        break;
    case 1000121003:
        dump_text_pNext<const VkDisplayPlaneInfo2KHR>(reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(object), settings, "VkDisplayPlaneInfo2KHR", indents, dump_text_VkDisplayPlaneInfo2KHR);
        break;
    case 1000121004:
        dump_text_pNext<const VkDisplayPlaneCapabilities2KHR>(reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(object), settings, "VkDisplayPlaneCapabilities2KHR", indents, dump_text_VkDisplayPlaneCapabilities2KHR);
        break;
#if defined(VK_USE_PLATFORM_IOS_MVK)
    case 1000122000:
        dump_text_pNext<const VkIOSSurfaceCreateInfoMVK>(reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(object), settings, "VkIOSSurfaceCreateInfoMVK", indents, dump_text_VkIOSSurfaceCreateInfoMVK);
        break;
#endif // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
    case 1000123000:
        dump_text_pNext<const VkMacOSSurfaceCreateInfoMVK>(reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(object), settings, "VkMacOSSurfaceCreateInfoMVK", indents, dump_text_VkMacOSSurfaceCreateInfoMVK);
        break;
#endif // VK_USE_PLATFORM_MACOS_MVK
    case 1000128002:
        dump_text_pNext<const VkDebugUtilsLabelEXT>(reinterpret_cast<const VkDebugUtilsLabelEXT*>(object), settings, "VkDebugUtilsLabelEXT", indents, dump_text_VkDebugUtilsLabelEXT);
        break;
    case 1000128000:
        dump_text_pNext<const VkDebugUtilsObjectNameInfoEXT>(reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(object), settings, "VkDebugUtilsObjectNameInfoEXT", indents, dump_text_VkDebugUtilsObjectNameInfoEXT);
        break;
    case 1000128003:
        dump_text_pNext<const VkDebugUtilsMessengerCallbackDataEXT>(reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(object), settings, "VkDebugUtilsMessengerCallbackDataEXT", indents, dump_text_VkDebugUtilsMessengerCallbackDataEXT);
        break;
    case 1000128004:
        dump_text_pNext<const VkDebugUtilsMessengerCreateInfoEXT>(reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(object), settings, "VkDebugUtilsMessengerCreateInfoEXT", indents, dump_text_VkDebugUtilsMessengerCreateInfoEXT);
        break;
    case 1000128001:
        dump_text_pNext<const VkDebugUtilsObjectTagInfoEXT>(reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(object), settings, "VkDebugUtilsObjectTagInfoEXT", indents, dump_text_VkDebugUtilsObjectTagInfoEXT);
        break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129000:
        dump_text_pNext<const VkAndroidHardwareBufferUsageANDROID>(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(object), settings, "VkAndroidHardwareBufferUsageANDROID", indents, dump_text_VkAndroidHardwareBufferUsageANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129001:
        dump_text_pNext<const VkAndroidHardwareBufferPropertiesANDROID>(reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(object), settings, "VkAndroidHardwareBufferPropertiesANDROID", indents, dump_text_VkAndroidHardwareBufferPropertiesANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129002:
        dump_text_pNext<const VkAndroidHardwareBufferFormatPropertiesANDROID>(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(object), settings, "VkAndroidHardwareBufferFormatPropertiesANDROID", indents, dump_text_VkAndroidHardwareBufferFormatPropertiesANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129003:
        dump_text_pNext<const VkImportAndroidHardwareBufferInfoANDROID>(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(object), settings, "VkImportAndroidHardwareBufferInfoANDROID", indents, dump_text_VkImportAndroidHardwareBufferInfoANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129004:
        dump_text_pNext<const VkMemoryGetAndroidHardwareBufferInfoANDROID>(reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(object), settings, "VkMemoryGetAndroidHardwareBufferInfoANDROID", indents, dump_text_VkMemoryGetAndroidHardwareBufferInfoANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129005:
        dump_text_pNext<const VkExternalFormatANDROID>(reinterpret_cast<const VkExternalFormatANDROID*>(object), settings, "VkExternalFormatANDROID", indents, dump_text_VkExternalFormatANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000129006:
        dump_text_pNext<const VkAndroidHardwareBufferFormatProperties2ANDROID>(reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(object), settings, "VkAndroidHardwareBufferFormatProperties2ANDROID", indents, dump_text_VkAndroidHardwareBufferFormatProperties2ANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000134000:
        dump_text_pNext<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX>(reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(object), settings, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX", indents, dump_text_VkPhysicalDeviceShaderEnqueueFeaturesAMDX);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000134001:
        dump_text_pNext<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX>(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(object), settings, "VkPhysicalDeviceShaderEnqueuePropertiesAMDX", indents, dump_text_VkPhysicalDeviceShaderEnqueuePropertiesAMDX);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000134002:
        dump_text_pNext<const VkExecutionGraphPipelineScratchSizeAMDX>(reinterpret_cast<const VkExecutionGraphPipelineScratchSizeAMDX*>(object), settings, "VkExecutionGraphPipelineScratchSizeAMDX", indents, dump_text_VkExecutionGraphPipelineScratchSizeAMDX);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000290000:
        dump_text_pNext<const VkPipelineLibraryCreateInfoKHR>(reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(object), settings, "VkPipelineLibraryCreateInfoKHR", indents, dump_text_VkPipelineLibraryCreateInfoKHR);
        break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000134003:
        dump_text_pNext<const VkExecutionGraphPipelineCreateInfoAMDX>(reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX*>(object), settings, "VkExecutionGraphPipelineCreateInfoAMDX", indents, dump_text_VkExecutionGraphPipelineCreateInfoAMDX);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000134004:
        dump_text_pNext<const VkPipelineShaderStageNodeCreateInfoAMDX>(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX*>(object), settings, "VkPipelineShaderStageNodeCreateInfoAMDX", indents, dump_text_VkPipelineShaderStageNodeCreateInfoAMDX);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000044008:
        dump_text_pNext<const VkAttachmentSampleCountInfoAMD>(reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(object), settings, "VkAttachmentSampleCountInfoAMD", indents, dump_text_VkAttachmentSampleCountInfoAMD);
        break;
    case 1000141000:
        dump_text_pNext<const VkPhysicalDeviceShaderBfloat16FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderBfloat16FeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderBfloat16FeaturesKHR);
        break;
    case 1000143000:
        dump_text_pNext<const VkSampleLocationsInfoEXT>(reinterpret_cast<const VkSampleLocationsInfoEXT*>(object), settings, "VkSampleLocationsInfoEXT", indents, dump_text_VkSampleLocationsInfoEXT);
        break;
    case 1000143001:
        dump_text_pNext<const VkRenderPassSampleLocationsBeginInfoEXT>(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(object), settings, "VkRenderPassSampleLocationsBeginInfoEXT", indents, dump_text_VkRenderPassSampleLocationsBeginInfoEXT);
        break;
    case 1000143002:
        dump_text_pNext<const VkPipelineSampleLocationsStateCreateInfoEXT>(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(object), settings, "VkPipelineSampleLocationsStateCreateInfoEXT", indents, dump_text_VkPipelineSampleLocationsStateCreateInfoEXT);
        break;
    case 1000143003:
        dump_text_pNext<const VkPhysicalDeviceSampleLocationsPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(object), settings, "VkPhysicalDeviceSampleLocationsPropertiesEXT", indents, dump_text_VkPhysicalDeviceSampleLocationsPropertiesEXT);
        break;
    case 1000143004:
        dump_text_pNext<const VkMultisamplePropertiesEXT>(reinterpret_cast<const VkMultisamplePropertiesEXT*>(object), settings, "VkMultisamplePropertiesEXT", indents, dump_text_VkMultisamplePropertiesEXT);
        break;
    case 1000148000:
        dump_text_pNext<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(object), settings, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", indents, dump_text_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
        break;
    case 1000148001:
        dump_text_pNext<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(object), settings, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT", indents, dump_text_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
        break;
    case 1000148002:
        dump_text_pNext<const VkPipelineColorBlendAdvancedStateCreateInfoEXT>(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(object), settings, "VkPipelineColorBlendAdvancedStateCreateInfoEXT", indents, dump_text_VkPipelineColorBlendAdvancedStateCreateInfoEXT);
        break;
    case 1000149000:
        dump_text_pNext<const VkPipelineCoverageToColorStateCreateInfoNV>(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(object), settings, "VkPipelineCoverageToColorStateCreateInfoNV", indents, dump_text_VkPipelineCoverageToColorStateCreateInfoNV);
        break;
    case 1000150005:
        dump_text_pNext<const VkAccelerationStructureGeometryTrianglesDataKHR>(reinterpret_cast<const VkAccelerationStructureGeometryTrianglesDataKHR*>(object), settings, "VkAccelerationStructureGeometryTrianglesDataKHR", indents, dump_text_VkAccelerationStructureGeometryTrianglesDataKHR);
        break;
    case 1000150003:
        dump_text_pNext<const VkAccelerationStructureGeometryAabbsDataKHR>(reinterpret_cast<const VkAccelerationStructureGeometryAabbsDataKHR*>(object), settings, "VkAccelerationStructureGeometryAabbsDataKHR", indents, dump_text_VkAccelerationStructureGeometryAabbsDataKHR);
        break;
    case 1000150004:
        dump_text_pNext<const VkAccelerationStructureGeometryInstancesDataKHR>(reinterpret_cast<const VkAccelerationStructureGeometryInstancesDataKHR*>(object), settings, "VkAccelerationStructureGeometryInstancesDataKHR", indents, dump_text_VkAccelerationStructureGeometryInstancesDataKHR);
        break;
    case 1000150006:
        dump_text_pNext<const VkAccelerationStructureGeometryKHR>(reinterpret_cast<const VkAccelerationStructureGeometryKHR*>(object), settings, "VkAccelerationStructureGeometryKHR", indents, dump_text_VkAccelerationStructureGeometryKHR);
        break;
    case 1000150000:
        dump_text_pNext<const VkAccelerationStructureBuildGeometryInfoKHR>(reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR*>(object), settings, "VkAccelerationStructureBuildGeometryInfoKHR", indents, dump_text_VkAccelerationStructureBuildGeometryInfoKHR);
        break;
    case 1000150017:
        dump_text_pNext<const VkAccelerationStructureCreateInfoKHR>(reinterpret_cast<const VkAccelerationStructureCreateInfoKHR*>(object), settings, "VkAccelerationStructureCreateInfoKHR", indents, dump_text_VkAccelerationStructureCreateInfoKHR);
        break;
    case 1000150007:
        dump_text_pNext<const VkWriteDescriptorSetAccelerationStructureKHR>(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(object), settings, "VkWriteDescriptorSetAccelerationStructureKHR", indents, dump_text_VkWriteDescriptorSetAccelerationStructureKHR);
        break;
    case 1000150013:
        dump_text_pNext<const VkPhysicalDeviceAccelerationStructureFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(object), settings, "VkPhysicalDeviceAccelerationStructureFeaturesKHR", indents, dump_text_VkPhysicalDeviceAccelerationStructureFeaturesKHR);
        break;
    case 1000150014:
        dump_text_pNext<const VkPhysicalDeviceAccelerationStructurePropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(object), settings, "VkPhysicalDeviceAccelerationStructurePropertiesKHR", indents, dump_text_VkPhysicalDeviceAccelerationStructurePropertiesKHR);
        break;
    case 1000150002:
        dump_text_pNext<const VkAccelerationStructureDeviceAddressInfoKHR>(reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR*>(object), settings, "VkAccelerationStructureDeviceAddressInfoKHR", indents, dump_text_VkAccelerationStructureDeviceAddressInfoKHR);
        break;
    case 1000150009:
        dump_text_pNext<const VkAccelerationStructureVersionInfoKHR>(reinterpret_cast<const VkAccelerationStructureVersionInfoKHR*>(object), settings, "VkAccelerationStructureVersionInfoKHR", indents, dump_text_VkAccelerationStructureVersionInfoKHR);
        break;
    case 1000150011:
        dump_text_pNext<const VkCopyAccelerationStructureToMemoryInfoKHR>(reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR*>(object), settings, "VkCopyAccelerationStructureToMemoryInfoKHR", indents, dump_text_VkCopyAccelerationStructureToMemoryInfoKHR);
        break;
    case 1000150012:
        dump_text_pNext<const VkCopyMemoryToAccelerationStructureInfoKHR>(reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR*>(object), settings, "VkCopyMemoryToAccelerationStructureInfoKHR", indents, dump_text_VkCopyMemoryToAccelerationStructureInfoKHR);
        break;
    case 1000150010:
        dump_text_pNext<const VkCopyAccelerationStructureInfoKHR>(reinterpret_cast<const VkCopyAccelerationStructureInfoKHR*>(object), settings, "VkCopyAccelerationStructureInfoKHR", indents, dump_text_VkCopyAccelerationStructureInfoKHR);
        break;
    case 1000150020:
        dump_text_pNext<const VkAccelerationStructureBuildSizesInfoKHR>(reinterpret_cast<const VkAccelerationStructureBuildSizesInfoKHR*>(object), settings, "VkAccelerationStructureBuildSizesInfoKHR", indents, dump_text_VkAccelerationStructureBuildSizesInfoKHR);
        break;
    case 1000152000:
        dump_text_pNext<const VkPipelineCoverageModulationStateCreateInfoNV>(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(object), settings, "VkPipelineCoverageModulationStateCreateInfoNV", indents, dump_text_VkPipelineCoverageModulationStateCreateInfoNV);
        break;
    case 1000154001:
        dump_text_pNext<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(object), settings, "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV", indents, dump_text_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV);
        break;
    case 1000154000:
        dump_text_pNext<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(object), settings, "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV", indents, dump_text_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV);
        break;
    case 1000158000:
        dump_text_pNext<const VkDrmFormatModifierPropertiesListEXT>(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(object), settings, "VkDrmFormatModifierPropertiesListEXT", indents, dump_text_VkDrmFormatModifierPropertiesListEXT);
        break;
    case 1000158002:
        dump_text_pNext<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT>(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(object), settings, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT", indents, dump_text_VkPhysicalDeviceImageDrmFormatModifierInfoEXT);
        break;
    case 1000158003:
        dump_text_pNext<const VkImageDrmFormatModifierListCreateInfoEXT>(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(object), settings, "VkImageDrmFormatModifierListCreateInfoEXT", indents, dump_text_VkImageDrmFormatModifierListCreateInfoEXT);
        break;
    case 1000158004:
        dump_text_pNext<const VkImageDrmFormatModifierExplicitCreateInfoEXT>(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(object), settings, "VkImageDrmFormatModifierExplicitCreateInfoEXT", indents, dump_text_VkImageDrmFormatModifierExplicitCreateInfoEXT);
        break;
    case 1000158005:
        dump_text_pNext<const VkImageDrmFormatModifierPropertiesEXT>(reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(object), settings, "VkImageDrmFormatModifierPropertiesEXT", indents, dump_text_VkImageDrmFormatModifierPropertiesEXT);
        break;
    case 1000158006:
        dump_text_pNext<const VkDrmFormatModifierPropertiesList2EXT>(reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(object), settings, "VkDrmFormatModifierPropertiesList2EXT", indents, dump_text_VkDrmFormatModifierPropertiesList2EXT);
        break;
    case 1000160000:
        dump_text_pNext<const VkValidationCacheCreateInfoEXT>(reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(object), settings, "VkValidationCacheCreateInfoEXT", indents, dump_text_VkValidationCacheCreateInfoEXT);
        break;
    case 1000160001:
        dump_text_pNext<const VkShaderModuleValidationCacheCreateInfoEXT>(reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(object), settings, "VkShaderModuleValidationCacheCreateInfoEXT", indents, dump_text_VkShaderModuleValidationCacheCreateInfoEXT);
        break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000163000:
        dump_text_pNext<const VkPhysicalDevicePortabilitySubsetFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(object), settings, "VkPhysicalDevicePortabilitySubsetFeaturesKHR", indents, dump_text_VkPhysicalDevicePortabilitySubsetFeaturesKHR);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000163001:
        dump_text_pNext<const VkPhysicalDevicePortabilitySubsetPropertiesKHR>(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(object), settings, "VkPhysicalDevicePortabilitySubsetPropertiesKHR", indents, dump_text_VkPhysicalDevicePortabilitySubsetPropertiesKHR);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000164000:
        dump_text_pNext<const VkPipelineViewportShadingRateImageStateCreateInfoNV>(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(object), settings, "VkPipelineViewportShadingRateImageStateCreateInfoNV", indents, dump_text_VkPipelineViewportShadingRateImageStateCreateInfoNV);
        break;
    case 1000164001:
        dump_text_pNext<const VkPhysicalDeviceShadingRateImageFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(object), settings, "VkPhysicalDeviceShadingRateImageFeaturesNV", indents, dump_text_VkPhysicalDeviceShadingRateImageFeaturesNV);
        break;
    case 1000164002:
        dump_text_pNext<const VkPhysicalDeviceShadingRateImagePropertiesNV>(reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(object), settings, "VkPhysicalDeviceShadingRateImagePropertiesNV", indents, dump_text_VkPhysicalDeviceShadingRateImagePropertiesNV);
        break;
    case 1000164005:
        dump_text_pNext<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(object), settings, "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV", indents, dump_text_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV);
        break;
    case 1000165011:
        dump_text_pNext<const VkRayTracingShaderGroupCreateInfoNV>(reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(object), settings, "VkRayTracingShaderGroupCreateInfoNV", indents, dump_text_VkRayTracingShaderGroupCreateInfoNV);
        break;
    case 1000165000:
        dump_text_pNext<const VkRayTracingPipelineCreateInfoNV>(reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(object), settings, "VkRayTracingPipelineCreateInfoNV", indents, dump_text_VkRayTracingPipelineCreateInfoNV);
        break;
    case 1000165004:
        dump_text_pNext<const VkGeometryTrianglesNV>(reinterpret_cast<const VkGeometryTrianglesNV*>(object), settings, "VkGeometryTrianglesNV", indents, dump_text_VkGeometryTrianglesNV);
        break;
    case 1000165005:
        dump_text_pNext<const VkGeometryAABBNV>(reinterpret_cast<const VkGeometryAABBNV*>(object), settings, "VkGeometryAABBNV", indents, dump_text_VkGeometryAABBNV);
        break;
    case 1000165003:
        dump_text_pNext<const VkGeometryNV>(reinterpret_cast<const VkGeometryNV*>(object), settings, "VkGeometryNV", indents, dump_text_VkGeometryNV);
        break;
    case 1000165012:
        dump_text_pNext<const VkAccelerationStructureInfoNV>(reinterpret_cast<const VkAccelerationStructureInfoNV*>(object), settings, "VkAccelerationStructureInfoNV", indents, dump_text_VkAccelerationStructureInfoNV);
        break;
    case 1000165001:
        dump_text_pNext<const VkAccelerationStructureCreateInfoNV>(reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(object), settings, "VkAccelerationStructureCreateInfoNV", indents, dump_text_VkAccelerationStructureCreateInfoNV);
        break;
    case 1000165006:
        dump_text_pNext<const VkBindAccelerationStructureMemoryInfoNV>(reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(object), settings, "VkBindAccelerationStructureMemoryInfoNV", indents, dump_text_VkBindAccelerationStructureMemoryInfoNV);
        break;
    case 1000165007:
        dump_text_pNext<const VkWriteDescriptorSetAccelerationStructureNV>(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(object), settings, "VkWriteDescriptorSetAccelerationStructureNV", indents, dump_text_VkWriteDescriptorSetAccelerationStructureNV);
        break;
    case 1000165008:
        dump_text_pNext<const VkAccelerationStructureMemoryRequirementsInfoNV>(reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(object), settings, "VkAccelerationStructureMemoryRequirementsInfoNV", indents, dump_text_VkAccelerationStructureMemoryRequirementsInfoNV);
        break;
    case 1000165009:
        dump_text_pNext<const VkPhysicalDeviceRayTracingPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(object), settings, "VkPhysicalDeviceRayTracingPropertiesNV", indents, dump_text_VkPhysicalDeviceRayTracingPropertiesNV);
        break;
    case 1000166000:
        dump_text_pNext<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(object), settings, "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV", indents, dump_text_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV);
        break;
    case 1000166001:
        dump_text_pNext<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV>(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(object), settings, "VkPipelineRepresentativeFragmentTestStateCreateInfoNV", indents, dump_text_VkPipelineRepresentativeFragmentTestStateCreateInfoNV);
        break;
    case 1000170000:
        dump_text_pNext<const VkPhysicalDeviceImageViewImageFormatInfoEXT>(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(object), settings, "VkPhysicalDeviceImageViewImageFormatInfoEXT", indents, dump_text_VkPhysicalDeviceImageViewImageFormatInfoEXT);
        break;
    case 1000170001:
        dump_text_pNext<const VkFilterCubicImageViewImageFormatPropertiesEXT>(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(object), settings, "VkFilterCubicImageViewImageFormatPropertiesEXT", indents, dump_text_VkFilterCubicImageViewImageFormatPropertiesEXT);
        break;
    case 1000178000:
        dump_text_pNext<const VkImportMemoryHostPointerInfoEXT>(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(object), settings, "VkImportMemoryHostPointerInfoEXT", indents, dump_text_VkImportMemoryHostPointerInfoEXT);
        break;
    case 1000178001:
        dump_text_pNext<const VkMemoryHostPointerPropertiesEXT>(reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(object), settings, "VkMemoryHostPointerPropertiesEXT", indents, dump_text_VkMemoryHostPointerPropertiesEXT);
        break;
    case 1000178002:
        dump_text_pNext<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(object), settings, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT", indents, dump_text_VkPhysicalDeviceExternalMemoryHostPropertiesEXT);
        break;
    case 1000181000:
        dump_text_pNext<const VkPhysicalDeviceShaderClockFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderClockFeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderClockFeaturesKHR);
        break;
    case 1000183000:
        dump_text_pNext<const VkPipelineCompilerControlCreateInfoAMD>(reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(object), settings, "VkPipelineCompilerControlCreateInfoAMD", indents, dump_text_VkPipelineCompilerControlCreateInfoAMD);
        break;
    case 1000184000:
        dump_text_pNext<const VkCalibratedTimestampInfoKHR>(reinterpret_cast<const VkCalibratedTimestampInfoKHR*>(object), settings, "VkCalibratedTimestampInfoKHR", indents, dump_text_VkCalibratedTimestampInfoKHR);
        break;
    case 1000185000:
        dump_text_pNext<const VkPhysicalDeviceShaderCorePropertiesAMD>(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(object), settings, "VkPhysicalDeviceShaderCorePropertiesAMD", indents, dump_text_VkPhysicalDeviceShaderCorePropertiesAMD);
        break;
    case 1000187003:
        dump_text_pNext<const VkVideoDecodeH265ProfileInfoKHR>(reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(object), settings, "VkVideoDecodeH265ProfileInfoKHR", indents, dump_text_VkVideoDecodeH265ProfileInfoKHR);
        break;
    case 1000187000:
        dump_text_pNext<const VkVideoDecodeH265CapabilitiesKHR>(reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(object), settings, "VkVideoDecodeH265CapabilitiesKHR", indents, dump_text_VkVideoDecodeH265CapabilitiesKHR);
        break;
    case 1000187002:
        dump_text_pNext<const VkVideoDecodeH265SessionParametersAddInfoKHR>(reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(object), settings, "VkVideoDecodeH265SessionParametersAddInfoKHR", indents, dump_text_VkVideoDecodeH265SessionParametersAddInfoKHR);
        break;
    case 1000187001:
        dump_text_pNext<const VkVideoDecodeH265SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(object), settings, "VkVideoDecodeH265SessionParametersCreateInfoKHR", indents, dump_text_VkVideoDecodeH265SessionParametersCreateInfoKHR);
        break;
    case 1000187004:
        dump_text_pNext<const VkVideoDecodeH265PictureInfoKHR>(reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(object), settings, "VkVideoDecodeH265PictureInfoKHR", indents, dump_text_VkVideoDecodeH265PictureInfoKHR);
        break;
    case 1000187005:
        dump_text_pNext<const VkVideoDecodeH265DpbSlotInfoKHR>(reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(object), settings, "VkVideoDecodeH265DpbSlotInfoKHR", indents, dump_text_VkVideoDecodeH265DpbSlotInfoKHR);
        break;
    case 1000189000:
        dump_text_pNext<const VkDeviceMemoryOverallocationCreateInfoAMD>(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(object), settings, "VkDeviceMemoryOverallocationCreateInfoAMD", indents, dump_text_VkDeviceMemoryOverallocationCreateInfoAMD);
        break;
    case 1000190000:
        dump_text_pNext<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(object), settings, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT", indents, dump_text_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
        break;
#if defined(VK_USE_PLATFORM_GGP)
    case 1000191000:
        dump_text_pNext<const VkPresentFrameTokenGGP>(reinterpret_cast<const VkPresentFrameTokenGGP*>(object), settings, "VkPresentFrameTokenGGP", indents, dump_text_VkPresentFrameTokenGGP);
        break;
#endif // VK_USE_PLATFORM_GGP
    case 1000201000:
        dump_text_pNext<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(object), settings, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR", indents, dump_text_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR);
        break;
    case 1000202000:
        dump_text_pNext<const VkPhysicalDeviceMeshShaderFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(object), settings, "VkPhysicalDeviceMeshShaderFeaturesNV", indents, dump_text_VkPhysicalDeviceMeshShaderFeaturesNV);
        break;
    case 1000202001:
        dump_text_pNext<const VkPhysicalDeviceMeshShaderPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(object), settings, "VkPhysicalDeviceMeshShaderPropertiesNV", indents, dump_text_VkPhysicalDeviceMeshShaderPropertiesNV);
        break;
    case 1000203000:
        dump_text_pNext<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(object), settings, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR", indents, dump_text_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
        break;
    case 1000204000:
        dump_text_pNext<const VkPhysicalDeviceShaderImageFootprintFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(object), settings, "VkPhysicalDeviceShaderImageFootprintFeaturesNV", indents, dump_text_VkPhysicalDeviceShaderImageFootprintFeaturesNV);
        break;
    case 1000205000:
        dump_text_pNext<const VkPipelineViewportExclusiveScissorStateCreateInfoNV>(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(object), settings, "VkPipelineViewportExclusiveScissorStateCreateInfoNV", indents, dump_text_VkPipelineViewportExclusiveScissorStateCreateInfoNV);
        break;
    case 1000205002:
        dump_text_pNext<const VkPhysicalDeviceExclusiveScissorFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(object), settings, "VkPhysicalDeviceExclusiveScissorFeaturesNV", indents, dump_text_VkPhysicalDeviceExclusiveScissorFeaturesNV);
        break;
    case 1000206001:
        dump_text_pNext<const VkQueueFamilyCheckpointPropertiesNV>(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(object), settings, "VkQueueFamilyCheckpointPropertiesNV", indents, dump_text_VkQueueFamilyCheckpointPropertiesNV);
        break;
    case 1000206000:
        dump_text_pNext<const VkCheckpointDataNV>(reinterpret_cast<const VkCheckpointDataNV*>(object), settings, "VkCheckpointDataNV", indents, dump_text_VkCheckpointDataNV);
        break;
    case 1000314008:
        dump_text_pNext<const VkQueueFamilyCheckpointProperties2NV>(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(object), settings, "VkQueueFamilyCheckpointProperties2NV", indents, dump_text_VkQueueFamilyCheckpointProperties2NV);
        break;
    case 1000314009:
        dump_text_pNext<const VkCheckpointData2NV>(reinterpret_cast<const VkCheckpointData2NV*>(object), settings, "VkCheckpointData2NV", indents, dump_text_VkCheckpointData2NV);
        break;
    case 1000209000:
        dump_text_pNext<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(object), settings, "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL", indents, dump_text_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL);
        break;
    case 1000210001:
        dump_text_pNext<const VkInitializePerformanceApiInfoINTEL>(reinterpret_cast<const VkInitializePerformanceApiInfoINTEL*>(object), settings, "VkInitializePerformanceApiInfoINTEL", indents, dump_text_VkInitializePerformanceApiInfoINTEL);
        break;
    case 1000210000:
        dump_text_pNext<const VkQueryPoolPerformanceQueryCreateInfoINTEL>(reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(object), settings, "VkQueryPoolPerformanceQueryCreateInfoINTEL", indents, dump_text_VkQueryPoolPerformanceQueryCreateInfoINTEL);
        break;
    case 1000210002:
        dump_text_pNext<const VkPerformanceMarkerInfoINTEL>(reinterpret_cast<const VkPerformanceMarkerInfoINTEL*>(object), settings, "VkPerformanceMarkerInfoINTEL", indents, dump_text_VkPerformanceMarkerInfoINTEL);
        break;
    case 1000210003:
        dump_text_pNext<const VkPerformanceStreamMarkerInfoINTEL>(reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL*>(object), settings, "VkPerformanceStreamMarkerInfoINTEL", indents, dump_text_VkPerformanceStreamMarkerInfoINTEL);
        break;
    case 1000210004:
        dump_text_pNext<const VkPerformanceOverrideInfoINTEL>(reinterpret_cast<const VkPerformanceOverrideInfoINTEL*>(object), settings, "VkPerformanceOverrideInfoINTEL", indents, dump_text_VkPerformanceOverrideInfoINTEL);
        break;
    case 1000210005:
        dump_text_pNext<const VkPerformanceConfigurationAcquireInfoINTEL>(reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL*>(object), settings, "VkPerformanceConfigurationAcquireInfoINTEL", indents, dump_text_VkPerformanceConfigurationAcquireInfoINTEL);
        break;
    case 1000212000:
        dump_text_pNext<const VkPhysicalDevicePCIBusInfoPropertiesEXT>(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(object), settings, "VkPhysicalDevicePCIBusInfoPropertiesEXT", indents, dump_text_VkPhysicalDevicePCIBusInfoPropertiesEXT);
        break;
    case 1000213000:
        dump_text_pNext<const VkDisplayNativeHdrSurfaceCapabilitiesAMD>(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(object), settings, "VkDisplayNativeHdrSurfaceCapabilitiesAMD", indents, dump_text_VkDisplayNativeHdrSurfaceCapabilitiesAMD);
        break;
    case 1000213001:
        dump_text_pNext<const VkSwapchainDisplayNativeHdrCreateInfoAMD>(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(object), settings, "VkSwapchainDisplayNativeHdrCreateInfoAMD", indents, dump_text_VkSwapchainDisplayNativeHdrCreateInfoAMD);
        break;
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000214000:
        dump_text_pNext<const VkImagePipeSurfaceCreateInfoFUCHSIA>(reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(object), settings, "VkImagePipeSurfaceCreateInfoFUCHSIA", indents, dump_text_VkImagePipeSurfaceCreateInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000217000:
        dump_text_pNext<const VkMetalSurfaceCreateInfoEXT>(reinterpret_cast<const VkMetalSurfaceCreateInfoEXT*>(object), settings, "VkMetalSurfaceCreateInfoEXT", indents, dump_text_VkMetalSurfaceCreateInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
    case 1000218000:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
        break;
    case 1000218001:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
        break;
    case 1000218002:
        dump_text_pNext<const VkRenderPassFragmentDensityMapCreateInfoEXT>(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(object), settings, "VkRenderPassFragmentDensityMapCreateInfoEXT", indents, dump_text_VkRenderPassFragmentDensityMapCreateInfoEXT);
        break;
    case 1000044007:
        dump_text_pNext<const VkRenderingFragmentDensityMapAttachmentInfoEXT>(reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(object), settings, "VkRenderingFragmentDensityMapAttachmentInfoEXT", indents, dump_text_VkRenderingFragmentDensityMapAttachmentInfoEXT);
        break;
    case 1000226000:
        dump_text_pNext<const VkFragmentShadingRateAttachmentInfoKHR>(reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(object), settings, "VkFragmentShadingRateAttachmentInfoKHR", indents, dump_text_VkFragmentShadingRateAttachmentInfoKHR);
        break;
    case 1000226001:
        dump_text_pNext<const VkPipelineFragmentShadingRateStateCreateInfoKHR>(reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(object), settings, "VkPipelineFragmentShadingRateStateCreateInfoKHR", indents, dump_text_VkPipelineFragmentShadingRateStateCreateInfoKHR);
        break;
    case 1000226003:
        dump_text_pNext<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(object), settings, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", indents, dump_text_VkPhysicalDeviceFragmentShadingRateFeaturesKHR);
        break;
    case 1000226002:
        dump_text_pNext<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(object), settings, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR", indents, dump_text_VkPhysicalDeviceFragmentShadingRatePropertiesKHR);
        break;
    case 1000226004:
        dump_text_pNext<const VkPhysicalDeviceFragmentShadingRateKHR>(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateKHR*>(object), settings, "VkPhysicalDeviceFragmentShadingRateKHR", indents, dump_text_VkPhysicalDeviceFragmentShadingRateKHR);
        break;
    case 1000044006:
        dump_text_pNext<const VkRenderingFragmentShadingRateAttachmentInfoKHR>(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(object), settings, "VkRenderingFragmentShadingRateAttachmentInfoKHR", indents, dump_text_VkRenderingFragmentShadingRateAttachmentInfoKHR);
        break;
    case 1000227000:
        dump_text_pNext<const VkPhysicalDeviceShaderCoreProperties2AMD>(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(object), settings, "VkPhysicalDeviceShaderCoreProperties2AMD", indents, dump_text_VkPhysicalDeviceShaderCoreProperties2AMD);
        break;
    case 1000229000:
        dump_text_pNext<const VkPhysicalDeviceCoherentMemoryFeaturesAMD>(reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(object), settings, "VkPhysicalDeviceCoherentMemoryFeaturesAMD", indents, dump_text_VkPhysicalDeviceCoherentMemoryFeaturesAMD);
        break;
    case 1000234000:
        dump_text_pNext<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT);
        break;
    case 1000235000:
        dump_text_pNext<const VkPhysicalDeviceShaderQuadControlFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderQuadControlFeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderQuadControlFeaturesKHR);
        break;
    case 1000237000:
        dump_text_pNext<const VkPhysicalDeviceMemoryBudgetPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(object), settings, "VkPhysicalDeviceMemoryBudgetPropertiesEXT", indents, dump_text_VkPhysicalDeviceMemoryBudgetPropertiesEXT);
        break;
    case 1000238000:
        dump_text_pNext<const VkPhysicalDeviceMemoryPriorityFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(object), settings, "VkPhysicalDeviceMemoryPriorityFeaturesEXT", indents, dump_text_VkPhysicalDeviceMemoryPriorityFeaturesEXT);
        break;
    case 1000238001:
        dump_text_pNext<const VkMemoryPriorityAllocateInfoEXT>(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(object), settings, "VkMemoryPriorityAllocateInfoEXT", indents, dump_text_VkMemoryPriorityAllocateInfoEXT);
        break;
    case 1000239000:
        dump_text_pNext<const VkSurfaceProtectedCapabilitiesKHR>(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(object), settings, "VkSurfaceProtectedCapabilitiesKHR", indents, dump_text_VkSurfaceProtectedCapabilitiesKHR);
        break;
    case 1000240000:
        dump_text_pNext<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(object), settings, "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV", indents, dump_text_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV);
        break;
    case 1000244000:
        dump_text_pNext<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(object), settings, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT", indents, dump_text_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT);
        break;
    case 1000244002:
        dump_text_pNext<const VkBufferDeviceAddressCreateInfoEXT>(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(object), settings, "VkBufferDeviceAddressCreateInfoEXT", indents, dump_text_VkBufferDeviceAddressCreateInfoEXT);
        break;
    case 1000247000:
        dump_text_pNext<const VkValidationFeaturesEXT>(reinterpret_cast<const VkValidationFeaturesEXT*>(object), settings, "VkValidationFeaturesEXT", indents, dump_text_VkValidationFeaturesEXT);
        break;
    case 1000248000:
        dump_text_pNext<const VkPhysicalDevicePresentWaitFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(object), settings, "VkPhysicalDevicePresentWaitFeaturesKHR", indents, dump_text_VkPhysicalDevicePresentWaitFeaturesKHR);
        break;
    case 1000249001:
        dump_text_pNext<const VkCooperativeMatrixPropertiesNV>(reinterpret_cast<const VkCooperativeMatrixPropertiesNV*>(object), settings, "VkCooperativeMatrixPropertiesNV", indents, dump_text_VkCooperativeMatrixPropertiesNV);
        break;
    case 1000249000:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrixFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(object), settings, "VkPhysicalDeviceCooperativeMatrixFeaturesNV", indents, dump_text_VkPhysicalDeviceCooperativeMatrixFeaturesNV);
        break;
    case 1000249002:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrixPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(object), settings, "VkPhysicalDeviceCooperativeMatrixPropertiesNV", indents, dump_text_VkPhysicalDeviceCooperativeMatrixPropertiesNV);
        break;
    case 1000250000:
        dump_text_pNext<const VkPhysicalDeviceCoverageReductionModeFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(object), settings, "VkPhysicalDeviceCoverageReductionModeFeaturesNV", indents, dump_text_VkPhysicalDeviceCoverageReductionModeFeaturesNV);
        break;
    case 1000250001:
        dump_text_pNext<const VkPipelineCoverageReductionStateCreateInfoNV>(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(object), settings, "VkPipelineCoverageReductionStateCreateInfoNV", indents, dump_text_VkPipelineCoverageReductionStateCreateInfoNV);
        break;
    case 1000250002:
        dump_text_pNext<const VkFramebufferMixedSamplesCombinationNV>(reinterpret_cast<const VkFramebufferMixedSamplesCombinationNV*>(object), settings, "VkFramebufferMixedSamplesCombinationNV", indents, dump_text_VkFramebufferMixedSamplesCombinationNV);
        break;
    case 1000251000:
        dump_text_pNext<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(object), settings, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", indents, dump_text_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT);
        break;
    case 1000252000:
        dump_text_pNext<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(object), settings, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", indents, dump_text_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT);
        break;
    case 1000254000:
        dump_text_pNext<const VkPhysicalDeviceProvokingVertexFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(object), settings, "VkPhysicalDeviceProvokingVertexFeaturesEXT", indents, dump_text_VkPhysicalDeviceProvokingVertexFeaturesEXT);
        break;
    case 1000254002:
        dump_text_pNext<const VkPhysicalDeviceProvokingVertexPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(object), settings, "VkPhysicalDeviceProvokingVertexPropertiesEXT", indents, dump_text_VkPhysicalDeviceProvokingVertexPropertiesEXT);
        break;
    case 1000254001:
        dump_text_pNext<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>(reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(object), settings, "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT", indents, dump_text_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT);
        break;
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000255000:
        dump_text_pNext<const VkSurfaceFullScreenExclusiveInfoEXT>(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(object), settings, "VkSurfaceFullScreenExclusiveInfoEXT", indents, dump_text_VkSurfaceFullScreenExclusiveInfoEXT);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000255002:
        dump_text_pNext<const VkSurfaceCapabilitiesFullScreenExclusiveEXT>(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(object), settings, "VkSurfaceCapabilitiesFullScreenExclusiveEXT", indents, dump_text_VkSurfaceCapabilitiesFullScreenExclusiveEXT);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
    case 1000255001:
        dump_text_pNext<const VkSurfaceFullScreenExclusiveWin32InfoEXT>(reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(object), settings, "VkSurfaceFullScreenExclusiveWin32InfoEXT", indents, dump_text_VkSurfaceFullScreenExclusiveWin32InfoEXT);
        break;
#endif // VK_USE_PLATFORM_WIN32_KHR
    case 1000256000:
        dump_text_pNext<const VkHeadlessSurfaceCreateInfoEXT>(reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT*>(object), settings, "VkHeadlessSurfaceCreateInfoEXT", indents, dump_text_VkHeadlessSurfaceCreateInfoEXT);
        break;
    case 1000260000:
        dump_text_pNext<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT);
        break;
    case 1000267000:
        dump_text_pNext<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(object), settings, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", indents, dump_text_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
        break;
    case 1000269000:
        dump_text_pNext<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(object), settings, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR", indents, dump_text_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
        break;
    case 1000269001:
        dump_text_pNext<const VkPipelineInfoKHR>(reinterpret_cast<const VkPipelineInfoKHR*>(object), settings, "VkPipelineInfoKHR", indents, dump_text_VkPipelineInfoKHR);
        break;
    case 1000269002:
        dump_text_pNext<const VkPipelineExecutablePropertiesKHR>(reinterpret_cast<const VkPipelineExecutablePropertiesKHR*>(object), settings, "VkPipelineExecutablePropertiesKHR", indents, dump_text_VkPipelineExecutablePropertiesKHR);
        break;
    case 1000269003:
        dump_text_pNext<const VkPipelineExecutableInfoKHR>(reinterpret_cast<const VkPipelineExecutableInfoKHR*>(object), settings, "VkPipelineExecutableInfoKHR", indents, dump_text_VkPipelineExecutableInfoKHR);
        break;
    case 1000269004:
        dump_text_pNext<const VkPipelineExecutableStatisticKHR>(reinterpret_cast<const VkPipelineExecutableStatisticKHR*>(object), settings, "VkPipelineExecutableStatisticKHR", indents, dump_text_VkPipelineExecutableStatisticKHR);
        break;
    case 1000269005:
        dump_text_pNext<const VkPipelineExecutableInternalRepresentationKHR>(reinterpret_cast<const VkPipelineExecutableInternalRepresentationKHR*>(object), settings, "VkPipelineExecutableInternalRepresentationKHR", indents, dump_text_VkPipelineExecutableInternalRepresentationKHR);
        break;
    case 1000272000:
        dump_text_pNext<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(object), settings, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT", indents, dump_text_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT);
        break;
    case 1000272001:
        dump_text_pNext<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(object), settings, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT", indents, dump_text_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT);
        break;
    case 1000272002:
        dump_text_pNext<const VkMemoryMapPlacedInfoEXT>(reinterpret_cast<const VkMemoryMapPlacedInfoEXT*>(object), settings, "VkMemoryMapPlacedInfoEXT", indents, dump_text_VkMemoryMapPlacedInfoEXT);
        break;
    case 1000273000:
        dump_text_pNext<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT);
        break;
    case 1000274000:
        dump_text_pNext<const VkSurfacePresentModeEXT>(reinterpret_cast<const VkSurfacePresentModeEXT*>(object), settings, "VkSurfacePresentModeEXT", indents, dump_text_VkSurfacePresentModeEXT);
        break;
    case 1000274001:
        dump_text_pNext<const VkSurfacePresentScalingCapabilitiesEXT>(reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(object), settings, "VkSurfacePresentScalingCapabilitiesEXT", indents, dump_text_VkSurfacePresentScalingCapabilitiesEXT);
        break;
    case 1000274002:
        dump_text_pNext<const VkSurfacePresentModeCompatibilityEXT>(reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(object), settings, "VkSurfacePresentModeCompatibilityEXT", indents, dump_text_VkSurfacePresentModeCompatibilityEXT);
        break;
    case 1000275000:
        dump_text_pNext<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(object), settings, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT", indents, dump_text_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT);
        break;
    case 1000275001:
        dump_text_pNext<const VkSwapchainPresentFenceInfoEXT>(reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(object), settings, "VkSwapchainPresentFenceInfoEXT", indents, dump_text_VkSwapchainPresentFenceInfoEXT);
        break;
    case 1000275002:
        dump_text_pNext<const VkSwapchainPresentModesCreateInfoEXT>(reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(object), settings, "VkSwapchainPresentModesCreateInfoEXT", indents, dump_text_VkSwapchainPresentModesCreateInfoEXT);
        break;
    case 1000275003:
        dump_text_pNext<const VkSwapchainPresentModeInfoEXT>(reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(object), settings, "VkSwapchainPresentModeInfoEXT", indents, dump_text_VkSwapchainPresentModeInfoEXT);
        break;
    case 1000275004:
        dump_text_pNext<const VkSwapchainPresentScalingCreateInfoEXT>(reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(object), settings, "VkSwapchainPresentScalingCreateInfoEXT", indents, dump_text_VkSwapchainPresentScalingCreateInfoEXT);
        break;
    case 1000275005:
        dump_text_pNext<const VkReleaseSwapchainImagesInfoEXT>(reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT*>(object), settings, "VkReleaseSwapchainImagesInfoEXT", indents, dump_text_VkReleaseSwapchainImagesInfoEXT);
        break;
    case 1000277000:
        dump_text_pNext<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(object), settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV", indents, dump_text_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV);
        break;
    case 1000277007:
        dump_text_pNext<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(object), settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV", indents, dump_text_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV);
        break;
    case 1000277001:
        dump_text_pNext<const VkGraphicsShaderGroupCreateInfoNV>(reinterpret_cast<const VkGraphicsShaderGroupCreateInfoNV*>(object), settings, "VkGraphicsShaderGroupCreateInfoNV", indents, dump_text_VkGraphicsShaderGroupCreateInfoNV);
        break;
    case 1000277002:
        dump_text_pNext<const VkGraphicsPipelineShaderGroupsCreateInfoNV>(reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(object), settings, "VkGraphicsPipelineShaderGroupsCreateInfoNV", indents, dump_text_VkGraphicsPipelineShaderGroupsCreateInfoNV);
        break;
    case 1000277003:
        dump_text_pNext<const VkIndirectCommandsLayoutTokenNV>(reinterpret_cast<const VkIndirectCommandsLayoutTokenNV*>(object), settings, "VkIndirectCommandsLayoutTokenNV", indents, dump_text_VkIndirectCommandsLayoutTokenNV);
        break;
    case 1000277004:
        dump_text_pNext<const VkIndirectCommandsLayoutCreateInfoNV>(reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV*>(object), settings, "VkIndirectCommandsLayoutCreateInfoNV", indents, dump_text_VkIndirectCommandsLayoutCreateInfoNV);
        break;
    case 1000277005:
        dump_text_pNext<const VkGeneratedCommandsInfoNV>(reinterpret_cast<const VkGeneratedCommandsInfoNV*>(object), settings, "VkGeneratedCommandsInfoNV", indents, dump_text_VkGeneratedCommandsInfoNV);
        break;
    case 1000277006:
        dump_text_pNext<const VkGeneratedCommandsMemoryRequirementsInfoNV>(reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV*>(object), settings, "VkGeneratedCommandsMemoryRequirementsInfoNV", indents, dump_text_VkGeneratedCommandsMemoryRequirementsInfoNV);
        break;
    case 1000278000:
        dump_text_pNext<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(object), settings, "VkPhysicalDeviceInheritedViewportScissorFeaturesNV", indents, dump_text_VkPhysicalDeviceInheritedViewportScissorFeaturesNV);
        break;
    case 1000278001:
        dump_text_pNext<const VkCommandBufferInheritanceViewportScissorInfoNV>(reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(object), settings, "VkCommandBufferInheritanceViewportScissorInfoNV", indents, dump_text_VkCommandBufferInheritanceViewportScissorInfoNV);
        break;
    case 1000281000:
        dump_text_pNext<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(object), settings, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", indents, dump_text_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
        break;
    case 1000282001:
        dump_text_pNext<const VkRenderPassTransformBeginInfoQCOM>(reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(object), settings, "VkRenderPassTransformBeginInfoQCOM", indents, dump_text_VkRenderPassTransformBeginInfoQCOM);
        break;
    case 1000282000:
        dump_text_pNext<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM>(reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(object), settings, "VkCommandBufferInheritanceRenderPassTransformInfoQCOM", indents, dump_text_VkCommandBufferInheritanceRenderPassTransformInfoQCOM);
        break;
    case 1000283000:
        dump_text_pNext<const VkPhysicalDeviceDepthBiasControlFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(object), settings, "VkPhysicalDeviceDepthBiasControlFeaturesEXT", indents, dump_text_VkPhysicalDeviceDepthBiasControlFeaturesEXT);
        break;
    case 1000283001:
        dump_text_pNext<const VkDepthBiasInfoEXT>(reinterpret_cast<const VkDepthBiasInfoEXT*>(object), settings, "VkDepthBiasInfoEXT", indents, dump_text_VkDepthBiasInfoEXT);
        break;
    case 1000283002:
        dump_text_pNext<const VkDepthBiasRepresentationInfoEXT>(reinterpret_cast<const VkDepthBiasRepresentationInfoEXT*>(object), settings, "VkDepthBiasRepresentationInfoEXT", indents, dump_text_VkDepthBiasRepresentationInfoEXT);
        break;
    case 1000284000:
        dump_text_pNext<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(object), settings, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT", indents, dump_text_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT);
        break;
    case 1000284002:
        dump_text_pNext<const VkDeviceMemoryReportCallbackDataEXT>(reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT*>(object), settings, "VkDeviceMemoryReportCallbackDataEXT", indents, dump_text_VkDeviceMemoryReportCallbackDataEXT);
        break;
    case 1000284001:
        dump_text_pNext<const VkDeviceDeviceMemoryReportCreateInfoEXT>(reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(object), settings, "VkDeviceDeviceMemoryReportCreateInfoEXT", indents, dump_text_VkDeviceDeviceMemoryReportCreateInfoEXT);
        break;
    case 1000286000:
        dump_text_pNext<const VkPhysicalDeviceRobustness2FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(object), settings, "VkPhysicalDeviceRobustness2FeaturesEXT", indents, dump_text_VkPhysicalDeviceRobustness2FeaturesEXT);
        break;
    case 1000286001:
        dump_text_pNext<const VkPhysicalDeviceRobustness2PropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(object), settings, "VkPhysicalDeviceRobustness2PropertiesEXT", indents, dump_text_VkPhysicalDeviceRobustness2PropertiesEXT);
        break;
    case 1000287000:
        dump_text_pNext<const VkSamplerCustomBorderColorCreateInfoEXT>(reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(object), settings, "VkSamplerCustomBorderColorCreateInfoEXT", indents, dump_text_VkSamplerCustomBorderColorCreateInfoEXT);
        break;
    case 1000287001:
        dump_text_pNext<const VkPhysicalDeviceCustomBorderColorPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(object), settings, "VkPhysicalDeviceCustomBorderColorPropertiesEXT", indents, dump_text_VkPhysicalDeviceCustomBorderColorPropertiesEXT);
        break;
    case 1000287002:
        dump_text_pNext<const VkPhysicalDeviceCustomBorderColorFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(object), settings, "VkPhysicalDeviceCustomBorderColorFeaturesEXT", indents, dump_text_VkPhysicalDeviceCustomBorderColorFeaturesEXT);
        break;
    case 1000292000:
        dump_text_pNext<const VkPhysicalDevicePresentBarrierFeaturesNV>(reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(object), settings, "VkPhysicalDevicePresentBarrierFeaturesNV", indents, dump_text_VkPhysicalDevicePresentBarrierFeaturesNV);
        break;
    case 1000292001:
        dump_text_pNext<const VkSurfaceCapabilitiesPresentBarrierNV>(reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(object), settings, "VkSurfaceCapabilitiesPresentBarrierNV", indents, dump_text_VkSurfaceCapabilitiesPresentBarrierNV);
        break;
    case 1000292002:
        dump_text_pNext<const VkSwapchainPresentBarrierCreateInfoNV>(reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(object), settings, "VkSwapchainPresentBarrierCreateInfoNV", indents, dump_text_VkSwapchainPresentBarrierCreateInfoNV);
        break;
    case 1000294000:
        dump_text_pNext<const VkPresentIdKHR>(reinterpret_cast<const VkPresentIdKHR*>(object), settings, "VkPresentIdKHR", indents, dump_text_VkPresentIdKHR);
        break;
    case 1000294001:
        dump_text_pNext<const VkPhysicalDevicePresentIdFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(object), settings, "VkPhysicalDevicePresentIdFeaturesKHR", indents, dump_text_VkPhysicalDevicePresentIdFeaturesKHR);
        break;
    case 1000299000:
        dump_text_pNext<const VkVideoEncodeInfoKHR>(reinterpret_cast<const VkVideoEncodeInfoKHR*>(object), settings, "VkVideoEncodeInfoKHR", indents, dump_text_VkVideoEncodeInfoKHR);
        break;
    case 1000299003:
        dump_text_pNext<const VkVideoEncodeCapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(object), settings, "VkVideoEncodeCapabilitiesKHR", indents, dump_text_VkVideoEncodeCapabilitiesKHR);
        break;
    case 1000299005:
        dump_text_pNext<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR>(reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(object), settings, "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR", indents, dump_text_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR);
        break;
    case 1000299004:
        dump_text_pNext<const VkVideoEncodeUsageInfoKHR>(reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(object), settings, "VkVideoEncodeUsageInfoKHR", indents, dump_text_VkVideoEncodeUsageInfoKHR);
        break;
    case 1000299002:
        dump_text_pNext<const VkVideoEncodeRateControlLayerInfoKHR>(reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(object), settings, "VkVideoEncodeRateControlLayerInfoKHR", indents, dump_text_VkVideoEncodeRateControlLayerInfoKHR);
        break;
    case 1000299001:
        dump_text_pNext<const VkVideoEncodeRateControlInfoKHR>(reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(object), settings, "VkVideoEncodeRateControlInfoKHR", indents, dump_text_VkVideoEncodeRateControlInfoKHR);
        break;
    case 1000299006:
        dump_text_pNext<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR>(reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(object), settings, "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR", indents, dump_text_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR);
        break;
    case 1000299007:
        dump_text_pNext<const VkVideoEncodeQualityLevelPropertiesKHR>(reinterpret_cast<const VkVideoEncodeQualityLevelPropertiesKHR*>(object), settings, "VkVideoEncodeQualityLevelPropertiesKHR", indents, dump_text_VkVideoEncodeQualityLevelPropertiesKHR);
        break;
    case 1000299008:
        dump_text_pNext<const VkVideoEncodeQualityLevelInfoKHR>(reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR*>(object), settings, "VkVideoEncodeQualityLevelInfoKHR", indents, dump_text_VkVideoEncodeQualityLevelInfoKHR);
        break;
    case 1000299009:
        dump_text_pNext<const VkVideoEncodeSessionParametersGetInfoKHR>(reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR*>(object), settings, "VkVideoEncodeSessionParametersGetInfoKHR", indents, dump_text_VkVideoEncodeSessionParametersGetInfoKHR);
        break;
    case 1000299010:
        dump_text_pNext<const VkVideoEncodeSessionParametersFeedbackInfoKHR>(reinterpret_cast<const VkVideoEncodeSessionParametersFeedbackInfoKHR*>(object), settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR", indents, dump_text_VkVideoEncodeSessionParametersFeedbackInfoKHR);
        break;
    case 1000300000:
        dump_text_pNext<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(object), settings, "VkPhysicalDeviceDiagnosticsConfigFeaturesNV", indents, dump_text_VkPhysicalDeviceDiagnosticsConfigFeaturesNV);
        break;
    case 1000300001:
        dump_text_pNext<const VkDeviceDiagnosticsConfigCreateInfoNV>(reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(object), settings, "VkDeviceDiagnosticsConfigCreateInfoNV", indents, dump_text_VkDeviceDiagnosticsConfigCreateInfoNV);
        break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000307000:
        dump_text_pNext<const VkCudaModuleCreateInfoNV>(reinterpret_cast<const VkCudaModuleCreateInfoNV*>(object), settings, "VkCudaModuleCreateInfoNV", indents, dump_text_VkCudaModuleCreateInfoNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000307001:
        dump_text_pNext<const VkCudaFunctionCreateInfoNV>(reinterpret_cast<const VkCudaFunctionCreateInfoNV*>(object), settings, "VkCudaFunctionCreateInfoNV", indents, dump_text_VkCudaFunctionCreateInfoNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000307002:
        dump_text_pNext<const VkCudaLaunchInfoNV>(reinterpret_cast<const VkCudaLaunchInfoNV*>(object), settings, "VkCudaLaunchInfoNV", indents, dump_text_VkCudaLaunchInfoNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000307003:
        dump_text_pNext<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(object), settings, "VkPhysicalDeviceCudaKernelLaunchFeaturesNV", indents, dump_text_VkPhysicalDeviceCudaKernelLaunchFeaturesNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000307004:
        dump_text_pNext<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(object), settings, "VkPhysicalDeviceCudaKernelLaunchPropertiesNV", indents, dump_text_VkPhysicalDeviceCudaKernelLaunchPropertiesNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000309000:
        dump_text_pNext<const VkPhysicalDeviceTileShadingFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM*>(object), settings, "VkPhysicalDeviceTileShadingFeaturesQCOM", indents, dump_text_VkPhysicalDeviceTileShadingFeaturesQCOM);
        break;
    case 1000309001:
        dump_text_pNext<const VkPhysicalDeviceTileShadingPropertiesQCOM>(reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM*>(object), settings, "VkPhysicalDeviceTileShadingPropertiesQCOM", indents, dump_text_VkPhysicalDeviceTileShadingPropertiesQCOM);
        break;
    case 1000309002:
        dump_text_pNext<const VkRenderPassTileShadingCreateInfoQCOM>(reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM*>(object), settings, "VkRenderPassTileShadingCreateInfoQCOM", indents, dump_text_VkRenderPassTileShadingCreateInfoQCOM);
        break;
    case 1000309003:
        dump_text_pNext<const VkPerTileBeginInfoQCOM>(reinterpret_cast<const VkPerTileBeginInfoQCOM*>(object), settings, "VkPerTileBeginInfoQCOM", indents, dump_text_VkPerTileBeginInfoQCOM);
        break;
    case 1000309004:
        dump_text_pNext<const VkPerTileEndInfoQCOM>(reinterpret_cast<const VkPerTileEndInfoQCOM*>(object), settings, "VkPerTileEndInfoQCOM", indents, dump_text_VkPerTileEndInfoQCOM);
        break;
    case 1000309005:
        dump_text_pNext<const VkDispatchTileInfoQCOM>(reinterpret_cast<const VkDispatchTileInfoQCOM*>(object), settings, "VkDispatchTileInfoQCOM", indents, dump_text_VkDispatchTileInfoQCOM);
        break;
    case 1000310000:
        dump_text_pNext<const VkQueryLowLatencySupportNV>(reinterpret_cast<const VkQueryLowLatencySupportNV*>(object), settings, "VkQueryLowLatencySupportNV", indents, dump_text_VkQueryLowLatencySupportNV);
        break;
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311000:
        dump_text_pNext<const VkExportMetalObjectCreateInfoEXT>(reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(object), settings, "VkExportMetalObjectCreateInfoEXT", indents, dump_text_VkExportMetalObjectCreateInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311001:
        dump_text_pNext<const VkExportMetalObjectsInfoEXT>(reinterpret_cast<const VkExportMetalObjectsInfoEXT*>(object), settings, "VkExportMetalObjectsInfoEXT", indents, dump_text_VkExportMetalObjectsInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311002:
        dump_text_pNext<const VkExportMetalDeviceInfoEXT>(reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(object), settings, "VkExportMetalDeviceInfoEXT", indents, dump_text_VkExportMetalDeviceInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311003:
        dump_text_pNext<const VkExportMetalCommandQueueInfoEXT>(reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(object), settings, "VkExportMetalCommandQueueInfoEXT", indents, dump_text_VkExportMetalCommandQueueInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311004:
        dump_text_pNext<const VkExportMetalBufferInfoEXT>(reinterpret_cast<const VkExportMetalBufferInfoEXT*>(object), settings, "VkExportMetalBufferInfoEXT", indents, dump_text_VkExportMetalBufferInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311005:
        dump_text_pNext<const VkImportMetalBufferInfoEXT>(reinterpret_cast<const VkImportMetalBufferInfoEXT*>(object), settings, "VkImportMetalBufferInfoEXT", indents, dump_text_VkImportMetalBufferInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311006:
        dump_text_pNext<const VkExportMetalTextureInfoEXT>(reinterpret_cast<const VkExportMetalTextureInfoEXT*>(object), settings, "VkExportMetalTextureInfoEXT", indents, dump_text_VkExportMetalTextureInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311007:
        dump_text_pNext<const VkImportMetalTextureInfoEXT>(reinterpret_cast<const VkImportMetalTextureInfoEXT*>(object), settings, "VkImportMetalTextureInfoEXT", indents, dump_text_VkImportMetalTextureInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311008:
        dump_text_pNext<const VkExportMetalIOSurfaceInfoEXT>(reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(object), settings, "VkExportMetalIOSurfaceInfoEXT", indents, dump_text_VkExportMetalIOSurfaceInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311009:
        dump_text_pNext<const VkImportMetalIOSurfaceInfoEXT>(reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(object), settings, "VkImportMetalIOSurfaceInfoEXT", indents, dump_text_VkImportMetalIOSurfaceInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311010:
        dump_text_pNext<const VkExportMetalSharedEventInfoEXT>(reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(object), settings, "VkExportMetalSharedEventInfoEXT", indents, dump_text_VkExportMetalSharedEventInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000311011:
        dump_text_pNext<const VkImportMetalSharedEventInfoEXT>(reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(object), settings, "VkImportMetalSharedEventInfoEXT", indents, dump_text_VkImportMetalSharedEventInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
    case 1000316000:
        dump_text_pNext<const VkPhysicalDeviceDescriptorBufferPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(object), settings, "VkPhysicalDeviceDescriptorBufferPropertiesEXT", indents, dump_text_VkPhysicalDeviceDescriptorBufferPropertiesEXT);
        break;
    case 1000316001:
        dump_text_pNext<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(object), settings, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT", indents, dump_text_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT);
        break;
    case 1000316002:
        dump_text_pNext<const VkPhysicalDeviceDescriptorBufferFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(object), settings, "VkPhysicalDeviceDescriptorBufferFeaturesEXT", indents, dump_text_VkPhysicalDeviceDescriptorBufferFeaturesEXT);
        break;
    case 1000316003:
        dump_text_pNext<const VkDescriptorAddressInfoEXT>(reinterpret_cast<const VkDescriptorAddressInfoEXT*>(object), settings, "VkDescriptorAddressInfoEXT", indents, dump_text_VkDescriptorAddressInfoEXT);
        break;
    case 1000316011:
        dump_text_pNext<const VkDescriptorBufferBindingInfoEXT>(reinterpret_cast<const VkDescriptorBufferBindingInfoEXT*>(object), settings, "VkDescriptorBufferBindingInfoEXT", indents, dump_text_VkDescriptorBufferBindingInfoEXT);
        break;
    case 1000316012:
        dump_text_pNext<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT>(reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(object), settings, "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT", indents, dump_text_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT);
        break;
    case 1000316004:
        dump_text_pNext<const VkDescriptorGetInfoEXT>(reinterpret_cast<const VkDescriptorGetInfoEXT*>(object), settings, "VkDescriptorGetInfoEXT", indents, dump_text_VkDescriptorGetInfoEXT);
        break;
    case 1000316005:
        dump_text_pNext<const VkBufferCaptureDescriptorDataInfoEXT>(reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT*>(object), settings, "VkBufferCaptureDescriptorDataInfoEXT", indents, dump_text_VkBufferCaptureDescriptorDataInfoEXT);
        break;
    case 1000316006:
        dump_text_pNext<const VkImageCaptureDescriptorDataInfoEXT>(reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT*>(object), settings, "VkImageCaptureDescriptorDataInfoEXT", indents, dump_text_VkImageCaptureDescriptorDataInfoEXT);
        break;
    case 1000316007:
        dump_text_pNext<const VkImageViewCaptureDescriptorDataInfoEXT>(reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT*>(object), settings, "VkImageViewCaptureDescriptorDataInfoEXT", indents, dump_text_VkImageViewCaptureDescriptorDataInfoEXT);
        break;
    case 1000316008:
        dump_text_pNext<const VkSamplerCaptureDescriptorDataInfoEXT>(reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT*>(object), settings, "VkSamplerCaptureDescriptorDataInfoEXT", indents, dump_text_VkSamplerCaptureDescriptorDataInfoEXT);
        break;
    case 1000316010:
        dump_text_pNext<const VkOpaqueCaptureDescriptorDataCreateInfoEXT>(reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(object), settings, "VkOpaqueCaptureDescriptorDataCreateInfoEXT", indents, dump_text_VkOpaqueCaptureDescriptorDataCreateInfoEXT);
        break;
    case 1000316009:
        dump_text_pNext<const VkAccelerationStructureCaptureDescriptorDataInfoEXT>(reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(object), settings, "VkAccelerationStructureCaptureDescriptorDataInfoEXT", indents, dump_text_VkAccelerationStructureCaptureDescriptorDataInfoEXT);
        break;
    case 1000320000:
        dump_text_pNext<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(object), settings, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT", indents, dump_text_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT);
        break;
    case 1000320001:
        dump_text_pNext<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(object), settings, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT", indents, dump_text_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT);
        break;
    case 1000320002:
        dump_text_pNext<const VkGraphicsPipelineLibraryCreateInfoEXT>(reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(object), settings, "VkGraphicsPipelineLibraryCreateInfoEXT", indents, dump_text_VkGraphicsPipelineLibraryCreateInfoEXT);
        break;
    case 1000321000:
        dump_text_pNext<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(object), settings, "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD", indents, dump_text_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD);
        break;
    case 1000322000:
        dump_text_pNext<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(object), settings, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR", indents, dump_text_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
        break;
    case 1000323000:
        dump_text_pNext<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR);
        break;
    case 1000326001:
        dump_text_pNext<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(object), settings, "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV", indents, dump_text_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV);
        break;
    case 1000326000:
        dump_text_pNext<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(object), settings, "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV", indents, dump_text_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV);
        break;
    case 1000326002:
        dump_text_pNext<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV>(reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(object), settings, "VkPipelineFragmentShadingRateEnumStateCreateInfoNV", indents, dump_text_VkPipelineFragmentShadingRateEnumStateCreateInfoNV);
        break;
    case 1000327000:
        dump_text_pNext<const VkAccelerationStructureGeometryMotionTrianglesDataNV>(reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(object), settings, "VkAccelerationStructureGeometryMotionTrianglesDataNV", indents, dump_text_VkAccelerationStructureGeometryMotionTrianglesDataNV);
        break;
    case 1000327002:
        dump_text_pNext<const VkAccelerationStructureMotionInfoNV>(reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(object), settings, "VkAccelerationStructureMotionInfoNV", indents, dump_text_VkAccelerationStructureMotionInfoNV);
        break;
    case 1000327001:
        dump_text_pNext<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(object), settings, "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV", indents, dump_text_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV);
        break;
    case 1000328000:
        dump_text_pNext<const VkPhysicalDeviceMeshShaderFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(object), settings, "VkPhysicalDeviceMeshShaderFeaturesEXT", indents, dump_text_VkPhysicalDeviceMeshShaderFeaturesEXT);
        break;
    case 1000328001:
        dump_text_pNext<const VkPhysicalDeviceMeshShaderPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(object), settings, "VkPhysicalDeviceMeshShaderPropertiesEXT", indents, dump_text_VkPhysicalDeviceMeshShaderPropertiesEXT);
        break;
    case 1000330000:
        dump_text_pNext<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(object), settings, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", indents, dump_text_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
        break;
    case 1000332000:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
        break;
    case 1000332001:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
        break;
    case 1000333000:
        dump_text_pNext<const VkCopyCommandTransformInfoQCOM>(reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(object), settings, "VkCopyCommandTransformInfoQCOM", indents, dump_text_VkCopyCommandTransformInfoQCOM);
        break;
    case 1000336000:
        dump_text_pNext<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(object), settings, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR", indents, dump_text_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
        break;
    case 1000338000:
        dump_text_pNext<const VkPhysicalDeviceImageCompressionControlFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(object), settings, "VkPhysicalDeviceImageCompressionControlFeaturesEXT", indents, dump_text_VkPhysicalDeviceImageCompressionControlFeaturesEXT);
        break;
    case 1000338001:
        dump_text_pNext<const VkImageCompressionControlEXT>(reinterpret_cast<const VkImageCompressionControlEXT*>(object), settings, "VkImageCompressionControlEXT", indents, dump_text_VkImageCompressionControlEXT);
        break;
    case 1000338004:
        dump_text_pNext<const VkImageCompressionPropertiesEXT>(reinterpret_cast<const VkImageCompressionPropertiesEXT*>(object), settings, "VkImageCompressionPropertiesEXT", indents, dump_text_VkImageCompressionPropertiesEXT);
        break;
    case 1000339000:
        dump_text_pNext<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(object), settings, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT", indents, dump_text_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT);
        break;
    case 1000340000:
        dump_text_pNext<const VkPhysicalDevice4444FormatsFeaturesEXT>(reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(object), settings, "VkPhysicalDevice4444FormatsFeaturesEXT", indents, dump_text_VkPhysicalDevice4444FormatsFeaturesEXT);
        break;
    case 1000341000:
        dump_text_pNext<const VkPhysicalDeviceFaultFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(object), settings, "VkPhysicalDeviceFaultFeaturesEXT", indents, dump_text_VkPhysicalDeviceFaultFeaturesEXT);
        break;
    case 1000341001:
        dump_text_pNext<const VkDeviceFaultCountsEXT>(reinterpret_cast<const VkDeviceFaultCountsEXT*>(object), settings, "VkDeviceFaultCountsEXT", indents, dump_text_VkDeviceFaultCountsEXT);
        break;
    case 1000341002:
        dump_text_pNext<const VkDeviceFaultInfoEXT>(reinterpret_cast<const VkDeviceFaultInfoEXT*>(object), settings, "VkDeviceFaultInfoEXT", indents, dump_text_VkDeviceFaultInfoEXT);
        break;
    case 1000342000:
        dump_text_pNext<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(object), settings, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT", indents, dump_text_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT);
        break;
    case 1000344000:
        dump_text_pNext<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(object), settings, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT", indents, dump_text_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
    case 1000346000:
        dump_text_pNext<const VkDirectFBSurfaceCreateInfoEXT>(reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT*>(object), settings, "VkDirectFBSurfaceCreateInfoEXT", indents, dump_text_VkDirectFBSurfaceCreateInfoEXT);
        break;
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
    case 1000150016:
        dump_text_pNext<const VkRayTracingShaderGroupCreateInfoKHR>(reinterpret_cast<const VkRayTracingShaderGroupCreateInfoKHR*>(object), settings, "VkRayTracingShaderGroupCreateInfoKHR", indents, dump_text_VkRayTracingShaderGroupCreateInfoKHR);
        break;
    case 1000150018:
        dump_text_pNext<const VkRayTracingPipelineInterfaceCreateInfoKHR>(reinterpret_cast<const VkRayTracingPipelineInterfaceCreateInfoKHR*>(object), settings, "VkRayTracingPipelineInterfaceCreateInfoKHR", indents, dump_text_VkRayTracingPipelineInterfaceCreateInfoKHR);
        break;
    case 1000150015:
        dump_text_pNext<const VkRayTracingPipelineCreateInfoKHR>(reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR*>(object), settings, "VkRayTracingPipelineCreateInfoKHR", indents, dump_text_VkRayTracingPipelineCreateInfoKHR);
        break;
    case 1000347000:
        dump_text_pNext<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(object), settings, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR", indents, dump_text_VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
        break;
    case 1000347001:
        dump_text_pNext<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(object), settings, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR", indents, dump_text_VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
        break;
    case 1000348013:
        dump_text_pNext<const VkPhysicalDeviceRayQueryFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(object), settings, "VkPhysicalDeviceRayQueryFeaturesKHR", indents, dump_text_VkPhysicalDeviceRayQueryFeaturesKHR);
        break;
    case 1000351000:
        dump_text_pNext<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(object), settings, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT", indents, dump_text_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT);
        break;
    case 1000351002:
        dump_text_pNext<const VkMutableDescriptorTypeCreateInfoEXT>(reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(object), settings, "VkMutableDescriptorTypeCreateInfoEXT", indents, dump_text_VkMutableDescriptorTypeCreateInfoEXT);
        break;
    case 1000352000:
        dump_text_pNext<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(object), settings, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", indents, dump_text_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT);
        break;
    case 1000352001:
        dump_text_pNext<const VkVertexInputBindingDescription2EXT>(reinterpret_cast<const VkVertexInputBindingDescription2EXT*>(object), settings, "VkVertexInputBindingDescription2EXT", indents, dump_text_VkVertexInputBindingDescription2EXT);
        break;
    case 1000352002:
        dump_text_pNext<const VkVertexInputAttributeDescription2EXT>(reinterpret_cast<const VkVertexInputAttributeDescription2EXT*>(object), settings, "VkVertexInputAttributeDescription2EXT", indents, dump_text_VkVertexInputAttributeDescription2EXT);
        break;
    case 1000353000:
        dump_text_pNext<const VkPhysicalDeviceDrmPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(object), settings, "VkPhysicalDeviceDrmPropertiesEXT", indents, dump_text_VkPhysicalDeviceDrmPropertiesEXT);
        break;
    case 1000354000:
        dump_text_pNext<const VkPhysicalDeviceAddressBindingReportFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(object), settings, "VkPhysicalDeviceAddressBindingReportFeaturesEXT", indents, dump_text_VkPhysicalDeviceAddressBindingReportFeaturesEXT);
        break;
    case 1000354001:
        dump_text_pNext<const VkDeviceAddressBindingCallbackDataEXT>(reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(object), settings, "VkDeviceAddressBindingCallbackDataEXT", indents, dump_text_VkDeviceAddressBindingCallbackDataEXT);
        break;
    case 1000355000:
        dump_text_pNext<const VkPhysicalDeviceDepthClipControlFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(object), settings, "VkPhysicalDeviceDepthClipControlFeaturesEXT", indents, dump_text_VkPhysicalDeviceDepthClipControlFeaturesEXT);
        break;
    case 1000355001:
        dump_text_pNext<const VkPipelineViewportDepthClipControlCreateInfoEXT>(reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(object), settings, "VkPipelineViewportDepthClipControlCreateInfoEXT", indents, dump_text_VkPipelineViewportDepthClipControlCreateInfoEXT);
        break;
    case 1000356000:
        dump_text_pNext<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(object), settings, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", indents, dump_text_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT);
        break;
    case 1000361000:
        dump_text_pNext<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT*>(object), settings, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT", indents, dump_text_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000364000:
        dump_text_pNext<const VkImportMemoryZirconHandleInfoFUCHSIA>(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(object), settings, "VkImportMemoryZirconHandleInfoFUCHSIA", indents, dump_text_VkImportMemoryZirconHandleInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000364001:
        dump_text_pNext<const VkMemoryZirconHandlePropertiesFUCHSIA>(reinterpret_cast<const VkMemoryZirconHandlePropertiesFUCHSIA*>(object), settings, "VkMemoryZirconHandlePropertiesFUCHSIA", indents, dump_text_VkMemoryZirconHandlePropertiesFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000364002:
        dump_text_pNext<const VkMemoryGetZirconHandleInfoFUCHSIA>(reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA*>(object), settings, "VkMemoryGetZirconHandleInfoFUCHSIA", indents, dump_text_VkMemoryGetZirconHandleInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000365000:
        dump_text_pNext<const VkImportSemaphoreZirconHandleInfoFUCHSIA>(reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA*>(object), settings, "VkImportSemaphoreZirconHandleInfoFUCHSIA", indents, dump_text_VkImportSemaphoreZirconHandleInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000365001:
        dump_text_pNext<const VkSemaphoreGetZirconHandleInfoFUCHSIA>(reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA*>(object), settings, "VkSemaphoreGetZirconHandleInfoFUCHSIA", indents, dump_text_VkSemaphoreGetZirconHandleInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366000:
        dump_text_pNext<const VkBufferCollectionCreateInfoFUCHSIA>(reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA*>(object), settings, "VkBufferCollectionCreateInfoFUCHSIA", indents, dump_text_VkBufferCollectionCreateInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366001:
        dump_text_pNext<const VkImportMemoryBufferCollectionFUCHSIA>(reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(object), settings, "VkImportMemoryBufferCollectionFUCHSIA", indents, dump_text_VkImportMemoryBufferCollectionFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366002:
        dump_text_pNext<const VkBufferCollectionImageCreateInfoFUCHSIA>(reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(object), settings, "VkBufferCollectionImageCreateInfoFUCHSIA", indents, dump_text_VkBufferCollectionImageCreateInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366009:
        dump_text_pNext<const VkBufferCollectionConstraintsInfoFUCHSIA>(reinterpret_cast<const VkBufferCollectionConstraintsInfoFUCHSIA*>(object), settings, "VkBufferCollectionConstraintsInfoFUCHSIA", indents, dump_text_VkBufferCollectionConstraintsInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366004:
        dump_text_pNext<const VkBufferConstraintsInfoFUCHSIA>(reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA*>(object), settings, "VkBufferConstraintsInfoFUCHSIA", indents, dump_text_VkBufferConstraintsInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366005:
        dump_text_pNext<const VkBufferCollectionBufferCreateInfoFUCHSIA>(reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(object), settings, "VkBufferCollectionBufferCreateInfoFUCHSIA", indents, dump_text_VkBufferCollectionBufferCreateInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366008:
        dump_text_pNext<const VkSysmemColorSpaceFUCHSIA>(reinterpret_cast<const VkSysmemColorSpaceFUCHSIA*>(object), settings, "VkSysmemColorSpaceFUCHSIA", indents, dump_text_VkSysmemColorSpaceFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366003:
        dump_text_pNext<const VkBufferCollectionPropertiesFUCHSIA>(reinterpret_cast<const VkBufferCollectionPropertiesFUCHSIA*>(object), settings, "VkBufferCollectionPropertiesFUCHSIA", indents, dump_text_VkBufferCollectionPropertiesFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366007:
        dump_text_pNext<const VkImageFormatConstraintsInfoFUCHSIA>(reinterpret_cast<const VkImageFormatConstraintsInfoFUCHSIA*>(object), settings, "VkImageFormatConstraintsInfoFUCHSIA", indents, dump_text_VkImageFormatConstraintsInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
    case 1000366006:
        dump_text_pNext<const VkImageConstraintsInfoFUCHSIA>(reinterpret_cast<const VkImageConstraintsInfoFUCHSIA*>(object), settings, "VkImageConstraintsInfoFUCHSIA", indents, dump_text_VkImageConstraintsInfoFUCHSIA);
        break;
#endif // VK_USE_PLATFORM_FUCHSIA
    case 1000369000:
        dump_text_pNext<const VkSubpassShadingPipelineCreateInfoHUAWEI>(reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(object), settings, "VkSubpassShadingPipelineCreateInfoHUAWEI", indents, dump_text_VkSubpassShadingPipelineCreateInfoHUAWEI);
        break;
    case 1000369001:
        dump_text_pNext<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(object), settings, "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI", indents, dump_text_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI);
        break;
    case 1000369002:
        dump_text_pNext<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(object), settings, "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI", indents, dump_text_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI);
        break;
    case 1000370000:
        dump_text_pNext<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(object), settings, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI", indents, dump_text_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI);
        break;
    case 1000371000:
        dump_text_pNext<const VkMemoryGetRemoteAddressInfoNV>(reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV*>(object), settings, "VkMemoryGetRemoteAddressInfoNV", indents, dump_text_VkMemoryGetRemoteAddressInfoNV);
        break;
    case 1000371001:
        dump_text_pNext<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(object), settings, "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV", indents, dump_text_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV);
        break;
    case 1000372000:
        dump_text_pNext<const VkPipelinePropertiesIdentifierEXT>(reinterpret_cast<const VkPipelinePropertiesIdentifierEXT*>(object), settings, "VkPipelinePropertiesIdentifierEXT", indents, dump_text_VkPipelinePropertiesIdentifierEXT);
        break;
    case 1000372001:
        dump_text_pNext<const VkPhysicalDevicePipelinePropertiesFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(object), settings, "VkPhysicalDevicePipelinePropertiesFeaturesEXT", indents, dump_text_VkPhysicalDevicePipelinePropertiesFeaturesEXT);
        break;
    case 1000375000:
        dump_text_pNext<const VkPhysicalDeviceFrameBoundaryFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(object), settings, "VkPhysicalDeviceFrameBoundaryFeaturesEXT", indents, dump_text_VkPhysicalDeviceFrameBoundaryFeaturesEXT);
        break;
    case 1000375001:
        dump_text_pNext<const VkFrameBoundaryEXT>(reinterpret_cast<const VkFrameBoundaryEXT*>(object), settings, "VkFrameBoundaryEXT", indents, dump_text_VkFrameBoundaryEXT);
        break;
    case 1000376000:
        dump_text_pNext<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(object), settings, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT", indents, dump_text_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT);
        break;
    case 1000376001:
        dump_text_pNext<const VkSubpassResolvePerformanceQueryEXT>(reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(object), settings, "VkSubpassResolvePerformanceQueryEXT", indents, dump_text_VkSubpassResolvePerformanceQueryEXT);
        break;
    case 1000376002:
        dump_text_pNext<const VkMultisampledRenderToSingleSampledInfoEXT>(reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(object), settings, "VkMultisampledRenderToSingleSampledInfoEXT", indents, dump_text_VkMultisampledRenderToSingleSampledInfoEXT);
        break;
    case 1000377000:
        dump_text_pNext<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(object), settings, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", indents, dump_text_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000378000:
        dump_text_pNext<const VkScreenSurfaceCreateInfoQNX>(reinterpret_cast<const VkScreenSurfaceCreateInfoQNX*>(object), settings, "VkScreenSurfaceCreateInfoQNX", indents, dump_text_VkScreenSurfaceCreateInfoQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
    case 1000381000:
        dump_text_pNext<const VkPhysicalDeviceColorWriteEnableFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(object), settings, "VkPhysicalDeviceColorWriteEnableFeaturesEXT", indents, dump_text_VkPhysicalDeviceColorWriteEnableFeaturesEXT);
        break;
    case 1000381001:
        dump_text_pNext<const VkPipelineColorWriteCreateInfoEXT>(reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(object), settings, "VkPipelineColorWriteCreateInfoEXT", indents, dump_text_VkPipelineColorWriteCreateInfoEXT);
        break;
    case 1000382000:
        dump_text_pNext<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(object), settings, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT", indents, dump_text_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT);
        break;
    case 1000386000:
        dump_text_pNext<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(object), settings, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR", indents, dump_text_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR);
        break;
    case 1000391000:
        dump_text_pNext<const VkPhysicalDeviceImageViewMinLodFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(object), settings, "VkPhysicalDeviceImageViewMinLodFeaturesEXT", indents, dump_text_VkPhysicalDeviceImageViewMinLodFeaturesEXT);
        break;
    case 1000391001:
        dump_text_pNext<const VkImageViewMinLodCreateInfoEXT>(reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(object), settings, "VkImageViewMinLodCreateInfoEXT", indents, dump_text_VkImageViewMinLodCreateInfoEXT);
        break;
    case 1000392000:
        dump_text_pNext<const VkPhysicalDeviceMultiDrawFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(object), settings, "VkPhysicalDeviceMultiDrawFeaturesEXT", indents, dump_text_VkPhysicalDeviceMultiDrawFeaturesEXT);
        break;
    case 1000392001:
        dump_text_pNext<const VkPhysicalDeviceMultiDrawPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(object), settings, "VkPhysicalDeviceMultiDrawPropertiesEXT", indents, dump_text_VkPhysicalDeviceMultiDrawPropertiesEXT);
        break;
    case 1000393000:
        dump_text_pNext<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(object), settings, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT", indents, dump_text_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT);
        break;
    case 1000395000:
        dump_text_pNext<const VkPhysicalDeviceShaderTileImageFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderTileImageFeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderTileImageFeaturesEXT);
        break;
    case 1000395001:
        dump_text_pNext<const VkPhysicalDeviceShaderTileImagePropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(object), settings, "VkPhysicalDeviceShaderTileImagePropertiesEXT", indents, dump_text_VkPhysicalDeviceShaderTileImagePropertiesEXT);
        break;
    case 1000396000:
        dump_text_pNext<const VkMicromapBuildInfoEXT>(reinterpret_cast<const VkMicromapBuildInfoEXT*>(object), settings, "VkMicromapBuildInfoEXT", indents, dump_text_VkMicromapBuildInfoEXT);
        break;
    case 1000396007:
        dump_text_pNext<const VkMicromapCreateInfoEXT>(reinterpret_cast<const VkMicromapCreateInfoEXT*>(object), settings, "VkMicromapCreateInfoEXT", indents, dump_text_VkMicromapCreateInfoEXT);
        break;
    case 1000396005:
        dump_text_pNext<const VkPhysicalDeviceOpacityMicromapFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(object), settings, "VkPhysicalDeviceOpacityMicromapFeaturesEXT", indents, dump_text_VkPhysicalDeviceOpacityMicromapFeaturesEXT);
        break;
    case 1000396006:
        dump_text_pNext<const VkPhysicalDeviceOpacityMicromapPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(object), settings, "VkPhysicalDeviceOpacityMicromapPropertiesEXT", indents, dump_text_VkPhysicalDeviceOpacityMicromapPropertiesEXT);
        break;
    case 1000396001:
        dump_text_pNext<const VkMicromapVersionInfoEXT>(reinterpret_cast<const VkMicromapVersionInfoEXT*>(object), settings, "VkMicromapVersionInfoEXT", indents, dump_text_VkMicromapVersionInfoEXT);
        break;
    case 1000396003:
        dump_text_pNext<const VkCopyMicromapToMemoryInfoEXT>(reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT*>(object), settings, "VkCopyMicromapToMemoryInfoEXT", indents, dump_text_VkCopyMicromapToMemoryInfoEXT);
        break;
    case 1000396004:
        dump_text_pNext<const VkCopyMemoryToMicromapInfoEXT>(reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT*>(object), settings, "VkCopyMemoryToMicromapInfoEXT", indents, dump_text_VkCopyMemoryToMicromapInfoEXT);
        break;
    case 1000396002:
        dump_text_pNext<const VkCopyMicromapInfoEXT>(reinterpret_cast<const VkCopyMicromapInfoEXT*>(object), settings, "VkCopyMicromapInfoEXT", indents, dump_text_VkCopyMicromapInfoEXT);
        break;
    case 1000396008:
        dump_text_pNext<const VkMicromapBuildSizesInfoEXT>(reinterpret_cast<const VkMicromapBuildSizesInfoEXT*>(object), settings, "VkMicromapBuildSizesInfoEXT", indents, dump_text_VkMicromapBuildSizesInfoEXT);
        break;
    case 1000396009:
        dump_text_pNext<const VkAccelerationStructureTrianglesOpacityMicromapEXT>(reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(object), settings, "VkAccelerationStructureTrianglesOpacityMicromapEXT", indents, dump_text_VkAccelerationStructureTrianglesOpacityMicromapEXT);
        break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000397000:
        dump_text_pNext<const VkPhysicalDeviceDisplacementMicromapFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(object), settings, "VkPhysicalDeviceDisplacementMicromapFeaturesNV", indents, dump_text_VkPhysicalDeviceDisplacementMicromapFeaturesNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000397001:
        dump_text_pNext<const VkPhysicalDeviceDisplacementMicromapPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(object), settings, "VkPhysicalDeviceDisplacementMicromapPropertiesNV", indents, dump_text_VkPhysicalDeviceDisplacementMicromapPropertiesNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000397002:
        dump_text_pNext<const VkAccelerationStructureTrianglesDisplacementMicromapNV>(reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(object), settings, "VkAccelerationStructureTrianglesDisplacementMicromapNV", indents, dump_text_VkAccelerationStructureTrianglesDisplacementMicromapNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000404000:
        dump_text_pNext<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(object), settings, "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI", indents, dump_text_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI);
        break;
    case 1000404001:
        dump_text_pNext<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(object), settings, "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI", indents, dump_text_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI);
        break;
    case 1000404002:
        dump_text_pNext<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(object), settings, "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI", indents, dump_text_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI);
        break;
    case 1000411000:
        dump_text_pNext<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(object), settings, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT", indents, dump_text_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT);
        break;
    case 1000411001:
        dump_text_pNext<const VkSamplerBorderColorComponentMappingCreateInfoEXT>(reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(object), settings, "VkSamplerBorderColorComponentMappingCreateInfoEXT", indents, dump_text_VkSamplerBorderColorComponentMappingCreateInfoEXT);
        break;
    case 1000412000:
        dump_text_pNext<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(object), settings, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT", indents, dump_text_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT);
        break;
    case 1000415000:
        dump_text_pNext<const VkPhysicalDeviceShaderCorePropertiesARM>(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(object), settings, "VkPhysicalDeviceShaderCorePropertiesARM", indents, dump_text_VkPhysicalDeviceShaderCorePropertiesARM);
        break;
    case 1000417000:
        dump_text_pNext<const VkDeviceQueueShaderCoreControlCreateInfoARM>(reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM*>(object), settings, "VkDeviceQueueShaderCoreControlCreateInfoARM", indents, dump_text_VkDeviceQueueShaderCoreControlCreateInfoARM);
        break;
    case 1000417001:
        dump_text_pNext<const VkPhysicalDeviceSchedulingControlsFeaturesARM>(reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM*>(object), settings, "VkPhysicalDeviceSchedulingControlsFeaturesARM", indents, dump_text_VkPhysicalDeviceSchedulingControlsFeaturesARM);
        break;
    case 1000417002:
        dump_text_pNext<const VkPhysicalDeviceSchedulingControlsPropertiesARM>(reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM*>(object), settings, "VkPhysicalDeviceSchedulingControlsPropertiesARM", indents, dump_text_VkPhysicalDeviceSchedulingControlsPropertiesARM);
        break;
    case 1000418000:
        dump_text_pNext<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(object), settings, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT", indents, dump_text_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT);
        break;
    case 1000418001:
        dump_text_pNext<const VkImageViewSlicedCreateInfoEXT>(reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(object), settings, "VkImageViewSlicedCreateInfoEXT", indents, dump_text_VkImageViewSlicedCreateInfoEXT);
        break;
    case 1000420000:
        dump_text_pNext<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(object), settings, "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE", indents, dump_text_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE);
        break;
    case 1000420001:
        dump_text_pNext<const VkDescriptorSetBindingReferenceVALVE>(reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE*>(object), settings, "VkDescriptorSetBindingReferenceVALVE", indents, dump_text_VkDescriptorSetBindingReferenceVALVE);
        break;
    case 1000420002:
        dump_text_pNext<const VkDescriptorSetLayoutHostMappingInfoVALVE>(reinterpret_cast<const VkDescriptorSetLayoutHostMappingInfoVALVE*>(object), settings, "VkDescriptorSetLayoutHostMappingInfoVALVE", indents, dump_text_VkDescriptorSetLayoutHostMappingInfoVALVE);
        break;
    case 1000421000:
        dump_text_pNext<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(object), settings, "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR", indents, dump_text_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR);
        break;
    case 1000422000:
        dump_text_pNext<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(object), settings, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT", indents, dump_text_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT);
        break;
    case 1000424000:
        dump_text_pNext<const VkPhysicalDeviceRenderPassStripedFeaturesARM>(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM*>(object), settings, "VkPhysicalDeviceRenderPassStripedFeaturesARM", indents, dump_text_VkPhysicalDeviceRenderPassStripedFeaturesARM);
        break;
    case 1000424001:
        dump_text_pNext<const VkPhysicalDeviceRenderPassStripedPropertiesARM>(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM*>(object), settings, "VkPhysicalDeviceRenderPassStripedPropertiesARM", indents, dump_text_VkPhysicalDeviceRenderPassStripedPropertiesARM);
        break;
    case 1000424003:
        dump_text_pNext<const VkRenderPassStripeInfoARM>(reinterpret_cast<const VkRenderPassStripeInfoARM*>(object), settings, "VkRenderPassStripeInfoARM", indents, dump_text_VkRenderPassStripeInfoARM);
        break;
    case 1000424002:
        dump_text_pNext<const VkRenderPassStripeBeginInfoARM>(reinterpret_cast<const VkRenderPassStripeBeginInfoARM*>(object), settings, "VkRenderPassStripeBeginInfoARM", indents, dump_text_VkRenderPassStripeBeginInfoARM);
        break;
    case 1000424004:
        dump_text_pNext<const VkRenderPassStripeSubmitInfoARM>(reinterpret_cast<const VkRenderPassStripeSubmitInfoARM*>(object), settings, "VkRenderPassStripeSubmitInfoARM", indents, dump_text_VkRenderPassStripeSubmitInfoARM);
        break;
    case 1000425000:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT);
        break;
    case 1000425001:
        dump_text_pNext<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(object), settings, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT", indents, dump_text_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT);
        break;
    case 1000425002:
        dump_text_pNext<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT>(reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(object), settings, "VkRenderPassFragmentDensityMapOffsetEndInfoEXT", indents, dump_text_VkRenderPassFragmentDensityMapOffsetEndInfoEXT);
        break;
    case 1000426000:
        dump_text_pNext<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(object), settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV", indents, dump_text_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV);
        break;
    case 1000426001:
        dump_text_pNext<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(object), settings, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV", indents, dump_text_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV);
        break;
    case 1000427000:
        dump_text_pNext<const VkPhysicalDeviceMemoryDecompressionFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(object), settings, "VkPhysicalDeviceMemoryDecompressionFeaturesNV", indents, dump_text_VkPhysicalDeviceMemoryDecompressionFeaturesNV);
        break;
    case 1000427001:
        dump_text_pNext<const VkPhysicalDeviceMemoryDecompressionPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(object), settings, "VkPhysicalDeviceMemoryDecompressionPropertiesNV", indents, dump_text_VkPhysicalDeviceMemoryDecompressionPropertiesNV);
        break;
    case 1000428000:
        dump_text_pNext<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(object), settings, "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV", indents, dump_text_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV);
        break;
    case 1000428001:
        dump_text_pNext<const VkComputePipelineIndirectBufferInfoNV>(reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV*>(object), settings, "VkComputePipelineIndirectBufferInfoNV", indents, dump_text_VkComputePipelineIndirectBufferInfoNV);
        break;
    case 1000428002:
        dump_text_pNext<const VkPipelineIndirectDeviceAddressInfoNV>(reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV*>(object), settings, "VkPipelineIndirectDeviceAddressInfoNV", indents, dump_text_VkPipelineIndirectDeviceAddressInfoNV);
        break;
    case 1000429008:
        dump_text_pNext<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(object), settings, "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV", indents, dump_text_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV);
        break;
    case 1000429009:
        dump_text_pNext<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV>(reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(object), settings, "VkAccelerationStructureGeometryLinearSweptSpheresDataNV", indents, dump_text_VkAccelerationStructureGeometryLinearSweptSpheresDataNV);
        break;
    case 1000429010:
        dump_text_pNext<const VkAccelerationStructureGeometrySpheresDataNV>(reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV*>(object), settings, "VkAccelerationStructureGeometrySpheresDataNV", indents, dump_text_VkAccelerationStructureGeometrySpheresDataNV);
        break;
    case 1000430000:
        dump_text_pNext<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(object), settings, "VkPhysicalDeviceLinearColorAttachmentFeaturesNV", indents, dump_text_VkPhysicalDeviceLinearColorAttachmentFeaturesNV);
        break;
    case 1000434000:
        dump_text_pNext<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR);
        break;
    case 1000437000:
        dump_text_pNext<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(object), settings, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT", indents, dump_text_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT);
        break;
    case 1000440002:
        dump_text_pNext<const VkImageViewSampleWeightCreateInfoQCOM>(reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(object), settings, "VkImageViewSampleWeightCreateInfoQCOM", indents, dump_text_VkImageViewSampleWeightCreateInfoQCOM);
        break;
    case 1000440000:
        dump_text_pNext<const VkPhysicalDeviceImageProcessingFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(object), settings, "VkPhysicalDeviceImageProcessingFeaturesQCOM", indents, dump_text_VkPhysicalDeviceImageProcessingFeaturesQCOM);
        break;
    case 1000440001:
        dump_text_pNext<const VkPhysicalDeviceImageProcessingPropertiesQCOM>(reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(object), settings, "VkPhysicalDeviceImageProcessingPropertiesQCOM", indents, dump_text_VkPhysicalDeviceImageProcessingPropertiesQCOM);
        break;
    case 1000451000:
        dump_text_pNext<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(object), settings, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT", indents, dump_text_VkPhysicalDeviceNestedCommandBufferFeaturesEXT);
        break;
    case 1000451001:
        dump_text_pNext<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(object), settings, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT", indents, dump_text_VkPhysicalDeviceNestedCommandBufferPropertiesEXT);
        break;
    case 1000453000:
        dump_text_pNext<const VkExternalMemoryAcquireUnmodifiedEXT>(reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT*>(object), settings, "VkExternalMemoryAcquireUnmodifiedEXT", indents, dump_text_VkExternalMemoryAcquireUnmodifiedEXT);
        break;
    case 1000455000:
        dump_text_pNext<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(object), settings, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT", indents, dump_text_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
        break;
    case 1000455001:
        dump_text_pNext<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(object), settings, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT", indents, dump_text_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
        break;
    case 1000458000:
        dump_text_pNext<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(object), settings, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT", indents, dump_text_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT);
        break;
    case 1000458001:
        dump_text_pNext<const VkRenderPassCreationControlEXT>(reinterpret_cast<const VkRenderPassCreationControlEXT*>(object), settings, "VkRenderPassCreationControlEXT", indents, dump_text_VkRenderPassCreationControlEXT);
        break;
    case 1000458002:
        dump_text_pNext<const VkRenderPassCreationFeedbackCreateInfoEXT>(reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(object), settings, "VkRenderPassCreationFeedbackCreateInfoEXT", indents, dump_text_VkRenderPassCreationFeedbackCreateInfoEXT);
        break;
    case 1000458003:
        dump_text_pNext<const VkRenderPassSubpassFeedbackCreateInfoEXT>(reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(object), settings, "VkRenderPassSubpassFeedbackCreateInfoEXT", indents, dump_text_VkRenderPassSubpassFeedbackCreateInfoEXT);
        break;
    case 1000459000:
        dump_text_pNext<const VkDirectDriverLoadingInfoLUNARG>(reinterpret_cast<const VkDirectDriverLoadingInfoLUNARG*>(object), settings, "VkDirectDriverLoadingInfoLUNARG", indents, dump_text_VkDirectDriverLoadingInfoLUNARG);
        break;
    case 1000459001:
        dump_text_pNext<const VkDirectDriverLoadingListLUNARG>(reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(object), settings, "VkDirectDriverLoadingListLUNARG", indents, dump_text_VkDirectDriverLoadingListLUNARG);
        break;
    case 1000462000:
        dump_text_pNext<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT);
        break;
    case 1000462001:
        dump_text_pNext<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(object), settings, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT", indents, dump_text_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT);
        break;
    case 1000462002:
        dump_text_pNext<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT>(reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(object), settings, "VkPipelineShaderStageModuleIdentifierCreateInfoEXT", indents, dump_text_VkPipelineShaderStageModuleIdentifierCreateInfoEXT);
        break;
    case 1000462003:
        dump_text_pNext<const VkShaderModuleIdentifierEXT>(reinterpret_cast<const VkShaderModuleIdentifierEXT*>(object), settings, "VkShaderModuleIdentifierEXT", indents, dump_text_VkShaderModuleIdentifierEXT);
        break;
    case 1000464000:
        dump_text_pNext<const VkPhysicalDeviceOpticalFlowFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(object), settings, "VkPhysicalDeviceOpticalFlowFeaturesNV", indents, dump_text_VkPhysicalDeviceOpticalFlowFeaturesNV);
        break;
    case 1000464001:
        dump_text_pNext<const VkPhysicalDeviceOpticalFlowPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(object), settings, "VkPhysicalDeviceOpticalFlowPropertiesNV", indents, dump_text_VkPhysicalDeviceOpticalFlowPropertiesNV);
        break;
    case 1000464002:
        dump_text_pNext<const VkOpticalFlowImageFormatInfoNV>(reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(object), settings, "VkOpticalFlowImageFormatInfoNV", indents, dump_text_VkOpticalFlowImageFormatInfoNV);
        break;
    case 1000464003:
        dump_text_pNext<const VkOpticalFlowImageFormatPropertiesNV>(reinterpret_cast<const VkOpticalFlowImageFormatPropertiesNV*>(object), settings, "VkOpticalFlowImageFormatPropertiesNV", indents, dump_text_VkOpticalFlowImageFormatPropertiesNV);
        break;
    case 1000464004:
        dump_text_pNext<const VkOpticalFlowSessionCreateInfoNV>(reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV*>(object), settings, "VkOpticalFlowSessionCreateInfoNV", indents, dump_text_VkOpticalFlowSessionCreateInfoNV);
        break;
    case 1000464010:
        dump_text_pNext<const VkOpticalFlowSessionCreatePrivateDataInfoNV>(reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(object), settings, "VkOpticalFlowSessionCreatePrivateDataInfoNV", indents, dump_text_VkOpticalFlowSessionCreatePrivateDataInfoNV);
        break;
    case 1000464005:
        dump_text_pNext<const VkOpticalFlowExecuteInfoNV>(reinterpret_cast<const VkOpticalFlowExecuteInfoNV*>(object), settings, "VkOpticalFlowExecuteInfoNV", indents, dump_text_VkOpticalFlowExecuteInfoNV);
        break;
    case 1000465000:
        dump_text_pNext<const VkPhysicalDeviceLegacyDitheringFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(object), settings, "VkPhysicalDeviceLegacyDitheringFeaturesEXT", indents, dump_text_VkPhysicalDeviceLegacyDitheringFeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000468000:
        dump_text_pNext<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID>(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(object), settings, "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID", indents, dump_text_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000468001:
        dump_text_pNext<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID>(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(object), settings, "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID", indents, dump_text_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    case 1000468002:
        dump_text_pNext<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(object), settings, "VkAndroidHardwareBufferFormatResolvePropertiesANDROID", indents, dump_text_VkAndroidHardwareBufferFormatResolvePropertiesANDROID);
        break;
#endif // VK_USE_PLATFORM_ANDROID_KHR
    case 1000476000:
        dump_text_pNext<const VkPhysicalDeviceAntiLagFeaturesAMD>(reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD*>(object), settings, "VkPhysicalDeviceAntiLagFeaturesAMD", indents, dump_text_VkPhysicalDeviceAntiLagFeaturesAMD);
        break;
    case 1000476002:
        dump_text_pNext<const VkAntiLagPresentationInfoAMD>(reinterpret_cast<const VkAntiLagPresentationInfoAMD*>(object), settings, "VkAntiLagPresentationInfoAMD", indents, dump_text_VkAntiLagPresentationInfoAMD);
        break;
    case 1000476001:
        dump_text_pNext<const VkAntiLagDataAMD>(reinterpret_cast<const VkAntiLagDataAMD*>(object), settings, "VkAntiLagDataAMD", indents, dump_text_VkAntiLagDataAMD);
        break;
    case 1000481000:
        dump_text_pNext<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(object), settings, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR", indents, dump_text_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
        break;
    case 1000482000:
        dump_text_pNext<const VkPhysicalDeviceShaderObjectFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderObjectFeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderObjectFeaturesEXT);
        break;
    case 1000482001:
        dump_text_pNext<const VkPhysicalDeviceShaderObjectPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(object), settings, "VkPhysicalDeviceShaderObjectPropertiesEXT", indents, dump_text_VkPhysicalDeviceShaderObjectPropertiesEXT);
        break;
    case 1000482002:
        dump_text_pNext<const VkShaderCreateInfoEXT>(reinterpret_cast<const VkShaderCreateInfoEXT*>(object), settings, "VkShaderCreateInfoEXT", indents, dump_text_VkShaderCreateInfoEXT);
        break;
    case 1000483000:
        dump_text_pNext<const VkPhysicalDevicePipelineBinaryFeaturesKHR>(reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR*>(object), settings, "VkPhysicalDevicePipelineBinaryFeaturesKHR", indents, dump_text_VkPhysicalDevicePipelineBinaryFeaturesKHR);
        break;
    case 1000483004:
        dump_text_pNext<const VkPhysicalDevicePipelineBinaryPropertiesKHR>(reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR*>(object), settings, "VkPhysicalDevicePipelineBinaryPropertiesKHR", indents, dump_text_VkPhysicalDevicePipelineBinaryPropertiesKHR);
        break;
    case 1000483008:
        dump_text_pNext<const VkDevicePipelineBinaryInternalCacheControlKHR>(reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR*>(object), settings, "VkDevicePipelineBinaryInternalCacheControlKHR", indents, dump_text_VkDevicePipelineBinaryInternalCacheControlKHR);
        break;
    case 1000483003:
        dump_text_pNext<const VkPipelineBinaryKeyKHR>(reinterpret_cast<const VkPipelineBinaryKeyKHR*>(object), settings, "VkPipelineBinaryKeyKHR", indents, dump_text_VkPipelineBinaryKeyKHR);
        break;
    case 1000483007:
        dump_text_pNext<const VkPipelineCreateInfoKHR>(reinterpret_cast<const VkPipelineCreateInfoKHR*>(object), settings, "VkPipelineCreateInfoKHR", indents, dump_text_VkPipelineCreateInfoKHR);
        break;
    case 1000483001:
        dump_text_pNext<const VkPipelineBinaryCreateInfoKHR>(reinterpret_cast<const VkPipelineBinaryCreateInfoKHR*>(object), settings, "VkPipelineBinaryCreateInfoKHR", indents, dump_text_VkPipelineBinaryCreateInfoKHR);
        break;
    case 1000483002:
        dump_text_pNext<const VkPipelineBinaryInfoKHR>(reinterpret_cast<const VkPipelineBinaryInfoKHR*>(object), settings, "VkPipelineBinaryInfoKHR", indents, dump_text_VkPipelineBinaryInfoKHR);
        break;
    case 1000483005:
        dump_text_pNext<const VkReleaseCapturedPipelineDataInfoKHR>(reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR*>(object), settings, "VkReleaseCapturedPipelineDataInfoKHR", indents, dump_text_VkReleaseCapturedPipelineDataInfoKHR);
        break;
    case 1000483006:
        dump_text_pNext<const VkPipelineBinaryDataInfoKHR>(reinterpret_cast<const VkPipelineBinaryDataInfoKHR*>(object), settings, "VkPipelineBinaryDataInfoKHR", indents, dump_text_VkPipelineBinaryDataInfoKHR);
        break;
    case 1000483009:
        dump_text_pNext<const VkPipelineBinaryHandlesInfoKHR>(reinterpret_cast<const VkPipelineBinaryHandlesInfoKHR*>(object), settings, "VkPipelineBinaryHandlesInfoKHR", indents, dump_text_VkPipelineBinaryHandlesInfoKHR);
        break;
    case 1000484000:
        dump_text_pNext<const VkPhysicalDeviceTilePropertiesFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(object), settings, "VkPhysicalDeviceTilePropertiesFeaturesQCOM", indents, dump_text_VkPhysicalDeviceTilePropertiesFeaturesQCOM);
        break;
    case 1000484001:
        dump_text_pNext<const VkTilePropertiesQCOM>(reinterpret_cast<const VkTilePropertiesQCOM*>(object), settings, "VkTilePropertiesQCOM", indents, dump_text_VkTilePropertiesQCOM);
        break;
    case 1000485000:
        dump_text_pNext<const VkPhysicalDeviceAmigoProfilingFeaturesSEC>(reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(object), settings, "VkPhysicalDeviceAmigoProfilingFeaturesSEC", indents, dump_text_VkPhysicalDeviceAmigoProfilingFeaturesSEC);
        break;
    case 1000485001:
        dump_text_pNext<const VkAmigoProfilingSubmitInfoSEC>(reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(object), settings, "VkAmigoProfilingSubmitInfoSEC", indents, dump_text_VkAmigoProfilingSubmitInfoSEC);
        break;
    case 1000488000:
        dump_text_pNext<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(object), settings, "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM", indents, dump_text_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM);
        break;
    case 1000490001:
        dump_text_pNext<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(object), settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV", indents, dump_text_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV);
        break;
    case 1000490000:
        dump_text_pNext<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(object), settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV", indents, dump_text_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV);
        break;
    case 1000491001:
        dump_text_pNext<const VkPhysicalDeviceCooperativeVectorPropertiesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV*>(object), settings, "VkPhysicalDeviceCooperativeVectorPropertiesNV", indents, dump_text_VkPhysicalDeviceCooperativeVectorPropertiesNV);
        break;
    case 1000491000:
        dump_text_pNext<const VkPhysicalDeviceCooperativeVectorFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV*>(object), settings, "VkPhysicalDeviceCooperativeVectorFeaturesNV", indents, dump_text_VkPhysicalDeviceCooperativeVectorFeaturesNV);
        break;
    case 1000491002:
        dump_text_pNext<const VkCooperativeVectorPropertiesNV>(reinterpret_cast<const VkCooperativeVectorPropertiesNV*>(object), settings, "VkCooperativeVectorPropertiesNV", indents, dump_text_VkCooperativeVectorPropertiesNV);
        break;
    case 1000491004:
        dump_text_pNext<const VkConvertCooperativeVectorMatrixInfoNV>(reinterpret_cast<const VkConvertCooperativeVectorMatrixInfoNV*>(object), settings, "VkConvertCooperativeVectorMatrixInfoNV", indents, dump_text_VkConvertCooperativeVectorMatrixInfoNV);
        break;
    case 1000492000:
        dump_text_pNext<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(object), settings, "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV", indents, dump_text_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV);
        break;
    case 1000492001:
        dump_text_pNext<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV>(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(object), settings, "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV", indents, dump_text_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV);
        break;
    case 1000495000:
        dump_text_pNext<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(object), settings, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT", indents, dump_text_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT);
        break;
    case 1000495001:
        dump_text_pNext<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(object), settings, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT", indents, dump_text_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT);
        break;
    case 1000496000:
        dump_text_pNext<const VkLayerSettingsCreateInfoEXT>(reinterpret_cast<const VkLayerSettingsCreateInfoEXT*>(object), settings, "VkLayerSettingsCreateInfoEXT", indents, dump_text_VkLayerSettingsCreateInfoEXT);
        break;
    case 1000497000:
        dump_text_pNext<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(object), settings, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM", indents, dump_text_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM);
        break;
    case 1000497001:
        dump_text_pNext<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(object), settings, "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM", indents, dump_text_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM);
        break;
    case 1000498000:
        dump_text_pNext<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>(reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(object), settings, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT", indents, dump_text_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT);
        break;
    case 1000499000:
        dump_text_pNext<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(object), settings, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT", indents, dump_text_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT);
        break;
    case 1000505000:
        dump_text_pNext<const VkLatencySleepModeInfoNV>(reinterpret_cast<const VkLatencySleepModeInfoNV*>(object), settings, "VkLatencySleepModeInfoNV", indents, dump_text_VkLatencySleepModeInfoNV);
        break;
    case 1000505001:
        dump_text_pNext<const VkLatencySleepInfoNV>(reinterpret_cast<const VkLatencySleepInfoNV*>(object), settings, "VkLatencySleepInfoNV", indents, dump_text_VkLatencySleepInfoNV);
        break;
    case 1000505002:
        dump_text_pNext<const VkSetLatencyMarkerInfoNV>(reinterpret_cast<const VkSetLatencyMarkerInfoNV*>(object), settings, "VkSetLatencyMarkerInfoNV", indents, dump_text_VkSetLatencyMarkerInfoNV);
        break;
    case 1000505004:
        dump_text_pNext<const VkLatencyTimingsFrameReportNV>(reinterpret_cast<const VkLatencyTimingsFrameReportNV*>(object), settings, "VkLatencyTimingsFrameReportNV", indents, dump_text_VkLatencyTimingsFrameReportNV);
        break;
    case 1000505003:
        dump_text_pNext<const VkGetLatencyMarkerInfoNV>(reinterpret_cast<const VkGetLatencyMarkerInfoNV*>(object), settings, "VkGetLatencyMarkerInfoNV", indents, dump_text_VkGetLatencyMarkerInfoNV);
        break;
    case 1000505005:
        dump_text_pNext<const VkLatencySubmissionPresentIdNV>(reinterpret_cast<const VkLatencySubmissionPresentIdNV*>(object), settings, "VkLatencySubmissionPresentIdNV", indents, dump_text_VkLatencySubmissionPresentIdNV);
        break;
    case 1000505007:
        dump_text_pNext<const VkSwapchainLatencyCreateInfoNV>(reinterpret_cast<const VkSwapchainLatencyCreateInfoNV*>(object), settings, "VkSwapchainLatencyCreateInfoNV", indents, dump_text_VkSwapchainLatencyCreateInfoNV);
        break;
    case 1000505006:
        dump_text_pNext<const VkOutOfBandQueueTypeInfoNV>(reinterpret_cast<const VkOutOfBandQueueTypeInfoNV*>(object), settings, "VkOutOfBandQueueTypeInfoNV", indents, dump_text_VkOutOfBandQueueTypeInfoNV);
        break;
    case 1000505008:
        dump_text_pNext<const VkLatencySurfaceCapabilitiesNV>(reinterpret_cast<const VkLatencySurfaceCapabilitiesNV*>(object), settings, "VkLatencySurfaceCapabilitiesNV", indents, dump_text_VkLatencySurfaceCapabilitiesNV);
        break;
    case 1000506001:
        dump_text_pNext<const VkCooperativeMatrixPropertiesKHR>(reinterpret_cast<const VkCooperativeMatrixPropertiesKHR*>(object), settings, "VkCooperativeMatrixPropertiesKHR", indents, dump_text_VkCooperativeMatrixPropertiesKHR);
        break;
    case 1000506000:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(object), settings, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR", indents, dump_text_VkPhysicalDeviceCooperativeMatrixFeaturesKHR);
        break;
    case 1000506002:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(object), settings, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR", indents, dump_text_VkPhysicalDeviceCooperativeMatrixPropertiesKHR);
        break;
    case 1000510000:
        dump_text_pNext<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(object), settings, "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM", indents, dump_text_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM);
        break;
    case 1000510001:
        dump_text_pNext<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>(reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(object), settings, "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM", indents, dump_text_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM);
        break;
    case 1000511000:
        dump_text_pNext<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(object), settings, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR", indents, dump_text_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR);
        break;
    case 1000512003:
        dump_text_pNext<const VkVideoDecodeAV1ProfileInfoKHR>(reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR*>(object), settings, "VkVideoDecodeAV1ProfileInfoKHR", indents, dump_text_VkVideoDecodeAV1ProfileInfoKHR);
        break;
    case 1000512000:
        dump_text_pNext<const VkVideoDecodeAV1CapabilitiesKHR>(reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR*>(object), settings, "VkVideoDecodeAV1CapabilitiesKHR", indents, dump_text_VkVideoDecodeAV1CapabilitiesKHR);
        break;
    case 1000512004:
        dump_text_pNext<const VkVideoDecodeAV1SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(object), settings, "VkVideoDecodeAV1SessionParametersCreateInfoKHR", indents, dump_text_VkVideoDecodeAV1SessionParametersCreateInfoKHR);
        break;
    case 1000512001:
        dump_text_pNext<const VkVideoDecodeAV1PictureInfoKHR>(reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR*>(object), settings, "VkVideoDecodeAV1PictureInfoKHR", indents, dump_text_VkVideoDecodeAV1PictureInfoKHR);
        break;
    case 1000512005:
        dump_text_pNext<const VkVideoDecodeAV1DpbSlotInfoKHR>(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR*>(object), settings, "VkVideoDecodeAV1DpbSlotInfoKHR", indents, dump_text_VkVideoDecodeAV1DpbSlotInfoKHR);
        break;
    case 1000513004:
        dump_text_pNext<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(object), settings, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR", indents, dump_text_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR);
        break;
    case 1000513000:
        dump_text_pNext<const VkVideoEncodeAV1CapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR*>(object), settings, "VkVideoEncodeAV1CapabilitiesKHR", indents, dump_text_VkVideoEncodeAV1CapabilitiesKHR);
        break;
    case 1000513008:
        dump_text_pNext<const VkVideoEncodeAV1QualityLevelPropertiesKHR>(reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR*>(object), settings, "VkVideoEncodeAV1QualityLevelPropertiesKHR", indents, dump_text_VkVideoEncodeAV1QualityLevelPropertiesKHR);
        break;
    case 1000513009:
        dump_text_pNext<const VkVideoEncodeAV1SessionCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR*>(object), settings, "VkVideoEncodeAV1SessionCreateInfoKHR", indents, dump_text_VkVideoEncodeAV1SessionCreateInfoKHR);
        break;
    case 1000513001:
        dump_text_pNext<const VkVideoEncodeAV1SessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(object), settings, "VkVideoEncodeAV1SessionParametersCreateInfoKHR", indents, dump_text_VkVideoEncodeAV1SessionParametersCreateInfoKHR);
        break;
    case 1000513002:
        dump_text_pNext<const VkVideoEncodeAV1PictureInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR*>(object), settings, "VkVideoEncodeAV1PictureInfoKHR", indents, dump_text_VkVideoEncodeAV1PictureInfoKHR);
        break;
    case 1000513003:
        dump_text_pNext<const VkVideoEncodeAV1DpbSlotInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR*>(object), settings, "VkVideoEncodeAV1DpbSlotInfoKHR", indents, dump_text_VkVideoEncodeAV1DpbSlotInfoKHR);
        break;
    case 1000513005:
        dump_text_pNext<const VkVideoEncodeAV1ProfileInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR*>(object), settings, "VkVideoEncodeAV1ProfileInfoKHR", indents, dump_text_VkVideoEncodeAV1ProfileInfoKHR);
        break;
    case 1000513010:
        dump_text_pNext<const VkVideoEncodeAV1GopRemainingFrameInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(object), settings, "VkVideoEncodeAV1GopRemainingFrameInfoKHR", indents, dump_text_VkVideoEncodeAV1GopRemainingFrameInfoKHR);
        break;
    case 1000513006:
        dump_text_pNext<const VkVideoEncodeAV1RateControlInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR*>(object), settings, "VkVideoEncodeAV1RateControlInfoKHR", indents, dump_text_VkVideoEncodeAV1RateControlInfoKHR);
        break;
    case 1000513007:
        dump_text_pNext<const VkVideoEncodeAV1RateControlLayerInfoKHR>(reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR*>(object), settings, "VkVideoEncodeAV1RateControlLayerInfoKHR", indents, dump_text_VkVideoEncodeAV1RateControlLayerInfoKHR);
        break;
    case 1000515000:
        dump_text_pNext<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(object), settings, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR", indents, dump_text_VkPhysicalDeviceVideoMaintenance1FeaturesKHR);
        break;
    case 1000515001:
        dump_text_pNext<const VkVideoInlineQueryInfoKHR>(reinterpret_cast<const VkVideoInlineQueryInfoKHR*>(object), settings, "VkVideoInlineQueryInfoKHR", indents, dump_text_VkVideoInlineQueryInfoKHR);
        break;
    case 1000516000:
        dump_text_pNext<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV>(reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(object), settings, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV", indents, dump_text_VkPhysicalDevicePerStageDescriptorSetFeaturesNV);
        break;
    case 1000518000:
        dump_text_pNext<const VkPhysicalDeviceImageProcessing2FeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(object), settings, "VkPhysicalDeviceImageProcessing2FeaturesQCOM", indents, dump_text_VkPhysicalDeviceImageProcessing2FeaturesQCOM);
        break;
    case 1000518001:
        dump_text_pNext<const VkPhysicalDeviceImageProcessing2PropertiesQCOM>(reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(object), settings, "VkPhysicalDeviceImageProcessing2PropertiesQCOM", indents, dump_text_VkPhysicalDeviceImageProcessing2PropertiesQCOM);
        break;
    case 1000518002:
        dump_text_pNext<const VkSamplerBlockMatchWindowCreateInfoQCOM>(reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM*>(object), settings, "VkSamplerBlockMatchWindowCreateInfoQCOM", indents, dump_text_VkSamplerBlockMatchWindowCreateInfoQCOM);
        break;
    case 1000519001:
        dump_text_pNext<const VkPhysicalDeviceCubicWeightsFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(object), settings, "VkPhysicalDeviceCubicWeightsFeaturesQCOM", indents, dump_text_VkPhysicalDeviceCubicWeightsFeaturesQCOM);
        break;
    case 1000519000:
        dump_text_pNext<const VkSamplerCubicWeightsCreateInfoQCOM>(reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM*>(object), settings, "VkSamplerCubicWeightsCreateInfoQCOM", indents, dump_text_VkSamplerCubicWeightsCreateInfoQCOM);
        break;
    case 1000519002:
        dump_text_pNext<const VkBlitImageCubicWeightsInfoQCOM>(reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM*>(object), settings, "VkBlitImageCubicWeightsInfoQCOM", indents, dump_text_VkBlitImageCubicWeightsInfoQCOM);
        break;
    case 1000520000:
        dump_text_pNext<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(object), settings, "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM", indents, dump_text_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM);
        break;
    case 1000520001:
        dump_text_pNext<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>(reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(object), settings, "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM", indents, dump_text_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM);
        break;
    case 1000521000:
        dump_text_pNext<const VkPhysicalDeviceCubicClampFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM*>(object), settings, "VkPhysicalDeviceCubicClampFeaturesQCOM", indents, dump_text_VkPhysicalDeviceCubicClampFeaturesQCOM);
        break;
    case 1000524000:
        dump_text_pNext<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(object), settings, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT", indents, dump_text_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT);
        break;
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000529000:
        dump_text_pNext<const VkScreenBufferPropertiesQNX>(reinterpret_cast<const VkScreenBufferPropertiesQNX*>(object), settings, "VkScreenBufferPropertiesQNX", indents, dump_text_VkScreenBufferPropertiesQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000529001:
        dump_text_pNext<const VkScreenBufferFormatPropertiesQNX>(reinterpret_cast<const VkScreenBufferFormatPropertiesQNX*>(object), settings, "VkScreenBufferFormatPropertiesQNX", indents, dump_text_VkScreenBufferFormatPropertiesQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000529002:
        dump_text_pNext<const VkImportScreenBufferInfoQNX>(reinterpret_cast<const VkImportScreenBufferInfoQNX*>(object), settings, "VkImportScreenBufferInfoQNX", indents, dump_text_VkImportScreenBufferInfoQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000529003:
        dump_text_pNext<const VkExternalFormatQNX>(reinterpret_cast<const VkExternalFormatQNX*>(object), settings, "VkExternalFormatQNX", indents, dump_text_VkExternalFormatQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
    case 1000529004:
        dump_text_pNext<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>(reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(object), settings, "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX", indents, dump_text_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX);
        break;
#endif // VK_USE_PLATFORM_SCREEN_QNX
    case 1000530000:
        dump_text_pNext<const VkPhysicalDeviceLayeredDriverPropertiesMSFT>(reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(object), settings, "VkPhysicalDeviceLayeredDriverPropertiesMSFT", indents, dump_text_VkPhysicalDeviceLayeredDriverPropertiesMSFT);
        break;
    case 1000545007:
        dump_text_pNext<const VkSetDescriptorBufferOffsetsInfoEXT>(reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT*>(object), settings, "VkSetDescriptorBufferOffsetsInfoEXT", indents, dump_text_VkSetDescriptorBufferOffsetsInfoEXT);
        break;
    case 1000545008:
        dump_text_pNext<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT>(reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(object), settings, "VkBindDescriptorBufferEmbeddedSamplersInfoEXT", indents, dump_text_VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
        break;
    case 1000546000:
        dump_text_pNext<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(object), settings, "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV", indents, dump_text_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV);
        break;
    case 1000547000:
        dump_text_pNext<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM>(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(object), settings, "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM", indents, dump_text_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM);
        break;
    case 1000547001:
        dump_text_pNext<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM>(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(object), settings, "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM", indents, dump_text_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM);
        break;
    case 1000547002:
        dump_text_pNext<const VkTileMemoryRequirementsQCOM>(reinterpret_cast<const VkTileMemoryRequirementsQCOM*>(object), settings, "VkTileMemoryRequirementsQCOM", indents, dump_text_VkTileMemoryRequirementsQCOM);
        break;
    case 1000547003:
        dump_text_pNext<const VkTileMemoryBindInfoQCOM>(reinterpret_cast<const VkTileMemoryBindInfoQCOM*>(object), settings, "VkTileMemoryBindInfoQCOM", indents, dump_text_VkTileMemoryBindInfoQCOM);
        break;
    case 1000547004:
        dump_text_pNext<const VkTileMemorySizeInfoQCOM>(reinterpret_cast<const VkTileMemorySizeInfoQCOM*>(object), settings, "VkTileMemorySizeInfoQCOM", indents, dump_text_VkTileMemorySizeInfoQCOM);
        break;
    case 1000551000:
        dump_text_pNext<const VkDisplaySurfaceStereoCreateInfoNV>(reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV*>(object), settings, "VkDisplaySurfaceStereoCreateInfoNV", indents, dump_text_VkDisplaySurfaceStereoCreateInfoNV);
        break;
    case 1000551001:
        dump_text_pNext<const VkDisplayModeStereoPropertiesNV>(reinterpret_cast<const VkDisplayModeStereoPropertiesNV*>(object), settings, "VkDisplayModeStereoPropertiesNV", indents, dump_text_VkDisplayModeStereoPropertiesNV);
        break;
    case 1000553000:
        dump_text_pNext<const VkVideoEncodeQuantizationMapCapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR*>(object), settings, "VkVideoEncodeQuantizationMapCapabilitiesKHR", indents, dump_text_VkVideoEncodeQuantizationMapCapabilitiesKHR);
        break;
    case 1000553001:
        dump_text_pNext<const VkVideoFormatQuantizationMapPropertiesKHR>(reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR*>(object), settings, "VkVideoFormatQuantizationMapPropertiesKHR", indents, dump_text_VkVideoFormatQuantizationMapPropertiesKHR);
        break;
    case 1000553002:
        dump_text_pNext<const VkVideoEncodeQuantizationMapInfoKHR>(reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR*>(object), settings, "VkVideoEncodeQuantizationMapInfoKHR", indents, dump_text_VkVideoEncodeQuantizationMapInfoKHR);
        break;
    case 1000553005:
        dump_text_pNext<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>(reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(object), settings, "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR", indents, dump_text_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR);
        break;
    case 1000553009:
        dump_text_pNext<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(object), settings, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR", indents, dump_text_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR);
        break;
    case 1000553003:
        dump_text_pNext<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(object), settings, "VkVideoEncodeH264QuantizationMapCapabilitiesKHR", indents, dump_text_VkVideoEncodeH264QuantizationMapCapabilitiesKHR);
        break;
    case 1000553004:
        dump_text_pNext<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(object), settings, "VkVideoEncodeH265QuantizationMapCapabilitiesKHR", indents, dump_text_VkVideoEncodeH265QuantizationMapCapabilitiesKHR);
        break;
    case 1000553006:
        dump_text_pNext<const VkVideoFormatH265QuantizationMapPropertiesKHR>(reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR*>(object), settings, "VkVideoFormatH265QuantizationMapPropertiesKHR", indents, dump_text_VkVideoFormatH265QuantizationMapPropertiesKHR);
        break;
    case 1000553007:
        dump_text_pNext<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>(reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(object), settings, "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR", indents, dump_text_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR);
        break;
    case 1000553008:
        dump_text_pNext<const VkVideoFormatAV1QuantizationMapPropertiesKHR>(reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR*>(object), settings, "VkVideoFormatAV1QuantizationMapPropertiesKHR", indents, dump_text_VkVideoFormatAV1QuantizationMapPropertiesKHR);
        break;
    case 1000555000:
        dump_text_pNext<const VkPhysicalDeviceRawAccessChainsFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV*>(object), settings, "VkPhysicalDeviceRawAccessChainsFeaturesNV", indents, dump_text_VkPhysicalDeviceRawAccessChainsFeaturesNV);
        break;
    case 1000556000:
        dump_text_pNext<const VkExternalComputeQueueDeviceCreateInfoNV>(reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV*>(object), settings, "VkExternalComputeQueueDeviceCreateInfoNV", indents, dump_text_VkExternalComputeQueueDeviceCreateInfoNV);
        break;
    case 1000556001:
        dump_text_pNext<const VkExternalComputeQueueCreateInfoNV>(reinterpret_cast<const VkExternalComputeQueueCreateInfoNV*>(object), settings, "VkExternalComputeQueueCreateInfoNV", indents, dump_text_VkExternalComputeQueueCreateInfoNV);
        break;
    case 1000556002:
        dump_text_pNext<const VkExternalComputeQueueDataParamsNV>(reinterpret_cast<const VkExternalComputeQueueDataParamsNV*>(object), settings, "VkExternalComputeQueueDataParamsNV", indents, dump_text_VkExternalComputeQueueDataParamsNV);
        break;
    case 1000556003:
        dump_text_pNext<const VkPhysicalDeviceExternalComputeQueuePropertiesNV>(reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(object), settings, "VkPhysicalDeviceExternalComputeQueuePropertiesNV", indents, dump_text_VkPhysicalDeviceExternalComputeQueuePropertiesNV);
        break;
    case 1000558000:
        dump_text_pNext<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(object), settings, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR", indents, dump_text_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR);
        break;
    case 1000559000:
        dump_text_pNext<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(object), settings, "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV", indents, dump_text_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV);
        break;
    case 1000562000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance7FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR*>(object), settings, "VkPhysicalDeviceMaintenance7FeaturesKHR", indents, dump_text_VkPhysicalDeviceMaintenance7FeaturesKHR);
        break;
    case 1000562001:
        dump_text_pNext<const VkPhysicalDeviceMaintenance7PropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR*>(object), settings, "VkPhysicalDeviceMaintenance7PropertiesKHR", indents, dump_text_VkPhysicalDeviceMaintenance7PropertiesKHR);
        break;
    case 1000562003:
        dump_text_pNext<const VkPhysicalDeviceLayeredApiPropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesKHR*>(object), settings, "VkPhysicalDeviceLayeredApiPropertiesKHR", indents, dump_text_VkPhysicalDeviceLayeredApiPropertiesKHR);
        break;
    case 1000562002:
        dump_text_pNext<const VkPhysicalDeviceLayeredApiPropertiesListKHR>(reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR*>(object), settings, "VkPhysicalDeviceLayeredApiPropertiesListKHR", indents, dump_text_VkPhysicalDeviceLayeredApiPropertiesListKHR);
        break;
    case 1000562004:
        dump_text_pNext<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>(reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(object), settings, "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR", indents, dump_text_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR);
        break;
    case 1000563000:
        dump_text_pNext<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(object), settings, "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV", indents, dump_text_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV);
        break;
    case 1000564000:
        dump_text_pNext<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(object), settings, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT", indents, dump_text_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT);
        break;
    case 1000568000:
        dump_text_pNext<const VkPhysicalDeviceRayTracingValidationFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV*>(object), settings, "VkPhysicalDeviceRayTracingValidationFeaturesNV", indents, dump_text_VkPhysicalDeviceRayTracingValidationFeaturesNV);
        break;
    case 1000569000:
        dump_text_pNext<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(object), settings, "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV", indents, dump_text_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV);
        break;
    case 1000569001:
        dump_text_pNext<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(object), settings, "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV", indents, dump_text_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV);
        break;
    case 1000569002:
        dump_text_pNext<const VkClusterAccelerationStructureClustersBottomLevelInputNV>(reinterpret_cast<const VkClusterAccelerationStructureClustersBottomLevelInputNV*>(object), settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV", indents, dump_text_VkClusterAccelerationStructureClustersBottomLevelInputNV);
        break;
    case 1000569003:
        dump_text_pNext<const VkClusterAccelerationStructureTriangleClusterInputNV>(reinterpret_cast<const VkClusterAccelerationStructureTriangleClusterInputNV*>(object), settings, "VkClusterAccelerationStructureTriangleClusterInputNV", indents, dump_text_VkClusterAccelerationStructureTriangleClusterInputNV);
        break;
    case 1000569004:
        dump_text_pNext<const VkClusterAccelerationStructureMoveObjectsInputNV>(reinterpret_cast<const VkClusterAccelerationStructureMoveObjectsInputNV*>(object), settings, "VkClusterAccelerationStructureMoveObjectsInputNV", indents, dump_text_VkClusterAccelerationStructureMoveObjectsInputNV);
        break;
    case 1000569005:
        dump_text_pNext<const VkClusterAccelerationStructureInputInfoNV>(reinterpret_cast<const VkClusterAccelerationStructureInputInfoNV*>(object), settings, "VkClusterAccelerationStructureInputInfoNV", indents, dump_text_VkClusterAccelerationStructureInputInfoNV);
        break;
    case 1000569006:
        dump_text_pNext<const VkClusterAccelerationStructureCommandsInfoNV>(reinterpret_cast<const VkClusterAccelerationStructureCommandsInfoNV*>(object), settings, "VkClusterAccelerationStructureCommandsInfoNV", indents, dump_text_VkClusterAccelerationStructureCommandsInfoNV);
        break;
    case 1000569007:
        dump_text_pNext<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV>(reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(object), settings, "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV", indents, dump_text_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV);
        break;
    case 1000570000:
        dump_text_pNext<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV>(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(object), settings, "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV", indents, dump_text_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV);
        break;
    case 1000570001:
        dump_text_pNext<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV>(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(object), settings, "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV", indents, dump_text_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV);
        break;
    case 1000570005:
        dump_text_pNext<const VkPartitionedAccelerationStructureFlagsNV>(reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV*>(object), settings, "VkPartitionedAccelerationStructureFlagsNV", indents, dump_text_VkPartitionedAccelerationStructureFlagsNV);
        break;
    case 1000570002:
        dump_text_pNext<const VkWriteDescriptorSetPartitionedAccelerationStructureNV>(reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(object), settings, "VkWriteDescriptorSetPartitionedAccelerationStructureNV", indents, dump_text_VkWriteDescriptorSetPartitionedAccelerationStructureNV);
        break;
    case 1000570003:
        dump_text_pNext<const VkPartitionedAccelerationStructureInstancesInputNV>(reinterpret_cast<const VkPartitionedAccelerationStructureInstancesInputNV*>(object), settings, "VkPartitionedAccelerationStructureInstancesInputNV", indents, dump_text_VkPartitionedAccelerationStructureInstancesInputNV);
        break;
    case 1000570004:
        dump_text_pNext<const VkBuildPartitionedAccelerationStructureInfoNV>(reinterpret_cast<const VkBuildPartitionedAccelerationStructureInfoNV*>(object), settings, "VkBuildPartitionedAccelerationStructureInfoNV", indents, dump_text_VkBuildPartitionedAccelerationStructureInfoNV);
        break;
    case 1000572000:
        dump_text_pNext<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(object), settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT", indents, dump_text_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT);
        break;
    case 1000572001:
        dump_text_pNext<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(object), settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT", indents, dump_text_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT);
        break;
    case 1000572002:
        dump_text_pNext<const VkGeneratedCommandsMemoryRequirementsInfoEXT>(reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoEXT*>(object), settings, "VkGeneratedCommandsMemoryRequirementsInfoEXT", indents, dump_text_VkGeneratedCommandsMemoryRequirementsInfoEXT);
        break;
    case 1000572010:
        dump_text_pNext<const VkIndirectExecutionSetPipelineInfoEXT>(reinterpret_cast<const VkIndirectExecutionSetPipelineInfoEXT*>(object), settings, "VkIndirectExecutionSetPipelineInfoEXT", indents, dump_text_VkIndirectExecutionSetPipelineInfoEXT);
        break;
    case 1000572012:
        dump_text_pNext<const VkIndirectExecutionSetShaderLayoutInfoEXT>(reinterpret_cast<const VkIndirectExecutionSetShaderLayoutInfoEXT*>(object), settings, "VkIndirectExecutionSetShaderLayoutInfoEXT", indents, dump_text_VkIndirectExecutionSetShaderLayoutInfoEXT);
        break;
    case 1000572011:
        dump_text_pNext<const VkIndirectExecutionSetShaderInfoEXT>(reinterpret_cast<const VkIndirectExecutionSetShaderInfoEXT*>(object), settings, "VkIndirectExecutionSetShaderInfoEXT", indents, dump_text_VkIndirectExecutionSetShaderInfoEXT);
        break;
    case 1000572003:
        dump_text_pNext<const VkIndirectExecutionSetCreateInfoEXT>(reinterpret_cast<const VkIndirectExecutionSetCreateInfoEXT*>(object), settings, "VkIndirectExecutionSetCreateInfoEXT", indents, dump_text_VkIndirectExecutionSetCreateInfoEXT);
        break;
    case 1000572004:
        dump_text_pNext<const VkGeneratedCommandsInfoEXT>(reinterpret_cast<const VkGeneratedCommandsInfoEXT*>(object), settings, "VkGeneratedCommandsInfoEXT", indents, dump_text_VkGeneratedCommandsInfoEXT);
        break;
    case 1000572008:
        dump_text_pNext<const VkWriteIndirectExecutionSetPipelineEXT>(reinterpret_cast<const VkWriteIndirectExecutionSetPipelineEXT*>(object), settings, "VkWriteIndirectExecutionSetPipelineEXT", indents, dump_text_VkWriteIndirectExecutionSetPipelineEXT);
        break;
    case 1000572007:
        dump_text_pNext<const VkIndirectCommandsLayoutTokenEXT>(reinterpret_cast<const VkIndirectCommandsLayoutTokenEXT*>(object), settings, "VkIndirectCommandsLayoutTokenEXT", indents, dump_text_VkIndirectCommandsLayoutTokenEXT);
        break;
    case 1000572006:
        dump_text_pNext<const VkIndirectCommandsLayoutCreateInfoEXT>(reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoEXT*>(object), settings, "VkIndirectCommandsLayoutCreateInfoEXT", indents, dump_text_VkIndirectCommandsLayoutCreateInfoEXT);
        break;
    case 1000572013:
        dump_text_pNext<const VkGeneratedCommandsPipelineInfoEXT>(reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT*>(object), settings, "VkGeneratedCommandsPipelineInfoEXT", indents, dump_text_VkGeneratedCommandsPipelineInfoEXT);
        break;
    case 1000572014:
        dump_text_pNext<const VkGeneratedCommandsShaderInfoEXT>(reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT*>(object), settings, "VkGeneratedCommandsShaderInfoEXT", indents, dump_text_VkGeneratedCommandsShaderInfoEXT);
        break;
    case 1000572009:
        dump_text_pNext<const VkWriteIndirectExecutionSetShaderEXT>(reinterpret_cast<const VkWriteIndirectExecutionSetShaderEXT*>(object), settings, "VkWriteIndirectExecutionSetShaderEXT", indents, dump_text_VkWriteIndirectExecutionSetShaderEXT);
        break;
    case 1000574000:
        dump_text_pNext<const VkPhysicalDeviceMaintenance8FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR*>(object), settings, "VkPhysicalDeviceMaintenance8FeaturesKHR", indents, dump_text_VkPhysicalDeviceMaintenance8FeaturesKHR);
        break;
    case 1000574002:
        dump_text_pNext<const VkMemoryBarrierAccessFlags3KHR>(reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR*>(object), settings, "VkMemoryBarrierAccessFlags3KHR", indents, dump_text_VkMemoryBarrierAccessFlags3KHR);
        break;
    case 1000575000:
        dump_text_pNext<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA>(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(object), settings, "VkPhysicalDeviceImageAlignmentControlFeaturesMESA", indents, dump_text_VkPhysicalDeviceImageAlignmentControlFeaturesMESA);
        break;
    case 1000575001:
        dump_text_pNext<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA>(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(object), settings, "VkPhysicalDeviceImageAlignmentControlPropertiesMESA", indents, dump_text_VkPhysicalDeviceImageAlignmentControlPropertiesMESA);
        break;
    case 1000575002:
        dump_text_pNext<const VkImageAlignmentControlCreateInfoMESA>(reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA*>(object), settings, "VkImageAlignmentControlCreateInfoMESA", indents, dump_text_VkImageAlignmentControlCreateInfoMESA);
        break;
    case 1000582000:
        dump_text_pNext<const VkPhysicalDeviceDepthClampControlFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT*>(object), settings, "VkPhysicalDeviceDepthClampControlFeaturesEXT", indents, dump_text_VkPhysicalDeviceDepthClampControlFeaturesEXT);
        break;
    case 1000582001:
        dump_text_pNext<const VkPipelineViewportDepthClampControlCreateInfoEXT>(reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT*>(object), settings, "VkPipelineViewportDepthClampControlCreateInfoEXT", indents, dump_text_VkPipelineViewportDepthClampControlCreateInfoEXT);
        break;
    case 1000586000:
        dump_text_pNext<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR>(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(object), settings, "VkPhysicalDeviceVideoMaintenance2FeaturesKHR", indents, dump_text_VkPhysicalDeviceVideoMaintenance2FeaturesKHR);
        break;
    case 1000586001:
        dump_text_pNext<const VkVideoDecodeH264InlineSessionParametersInfoKHR>(reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR*>(object), settings, "VkVideoDecodeH264InlineSessionParametersInfoKHR", indents, dump_text_VkVideoDecodeH264InlineSessionParametersInfoKHR);
        break;
    case 1000586002:
        dump_text_pNext<const VkVideoDecodeH265InlineSessionParametersInfoKHR>(reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR*>(object), settings, "VkVideoDecodeH265InlineSessionParametersInfoKHR", indents, dump_text_VkVideoDecodeH265InlineSessionParametersInfoKHR);
        break;
    case 1000586003:
        dump_text_pNext<const VkVideoDecodeAV1InlineSessionParametersInfoKHR>(reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(object), settings, "VkVideoDecodeAV1InlineSessionParametersInfoKHR", indents, dump_text_VkVideoDecodeAV1InlineSessionParametersInfoKHR);
        break;
    case 1000590000:
        dump_text_pNext<const VkPhysicalDeviceHdrVividFeaturesHUAWEI>(reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(object), settings, "VkPhysicalDeviceHdrVividFeaturesHUAWEI", indents, dump_text_VkPhysicalDeviceHdrVividFeaturesHUAWEI);
        break;
    case 1000590001:
        dump_text_pNext<const VkHdrVividDynamicMetadataHUAWEI>(reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI*>(object), settings, "VkHdrVividDynamicMetadataHUAWEI", indents, dump_text_VkHdrVividDynamicMetadataHUAWEI);
        break;
    case 1000593001:
        dump_text_pNext<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV>(reinterpret_cast<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV*>(object), settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV", indents, dump_text_VkCooperativeMatrixFlexibleDimensionsPropertiesNV);
        break;
    case 1000593000:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(object), settings, "VkPhysicalDeviceCooperativeMatrix2FeaturesNV", indents, dump_text_VkPhysicalDeviceCooperativeMatrix2FeaturesNV);
        break;
    case 1000593002:
        dump_text_pNext<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV>(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(object), settings, "VkPhysicalDeviceCooperativeMatrix2PropertiesNV", indents, dump_text_VkPhysicalDeviceCooperativeMatrix2PropertiesNV);
        break;
    case 1000596000:
        dump_text_pNext<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM>(reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(object), settings, "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM", indents, dump_text_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM);
        break;
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000602000:
        dump_text_pNext<const VkImportMemoryMetalHandleInfoEXT>(reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT*>(object), settings, "VkImportMemoryMetalHandleInfoEXT", indents, dump_text_VkImportMemoryMetalHandleInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000602001:
        dump_text_pNext<const VkMemoryMetalHandlePropertiesEXT>(reinterpret_cast<const VkMemoryMetalHandlePropertiesEXT*>(object), settings, "VkMemoryMetalHandlePropertiesEXT", indents, dump_text_VkMemoryMetalHandlePropertiesEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
    case 1000602002:
        dump_text_pNext<const VkMemoryGetMetalHandleInfoEXT>(reinterpret_cast<const VkMemoryGetMetalHandleInfoEXT*>(object), settings, "VkMemoryGetMetalHandleInfoEXT", indents, dump_text_VkMemoryGetMetalHandleInfoEXT);
        break;
#endif // VK_USE_PLATFORM_METAL_EXT
    case 1000608000:
        dump_text_pNext<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(object), settings, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT", indents, dump_text_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT);
        break;
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000613000:
        dump_text_pNext<const VkSetPresentConfigNV>(reinterpret_cast<const VkSetPresentConfigNV*>(object), settings, "VkSetPresentConfigNV", indents, dump_text_VkSetPresentConfigNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
    case 1000613001:
        dump_text_pNext<const VkPhysicalDevicePresentMeteringFeaturesNV>(reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV*>(object), settings, "VkPhysicalDevicePresentMeteringFeaturesNV", indents, dump_text_VkPhysicalDevicePresentMeteringFeaturesNV);
        break;
#endif // VK_ENABLE_BETA_EXTENSIONS
    case 1000619003:
        dump_text_pNext<const VkRenderingEndInfoEXT>(reinterpret_cast<const VkRenderingEndInfoEXT*>(object), settings, "VkRenderingEndInfoEXT", indents, dump_text_VkRenderingEndInfoEXT);
        break;
    case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: // 47
    case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: // 48
        if(base_struct->pNext != nullptr){
            dump_text_pNext_trampoline(reinterpret_cast<const void*>(base_struct->pNext), settings, indents);
        } else {
            settings.formatNameType(indents, "pNext", "const void*");
            settings.stream() << "NULL\n";
        }
        break;
    default:
        settings.formatNameType(indents, "pNext", "const void*");
        settings.stream() << "UNKNOWN (" << (int64_t) (base_struct->sType) << ")\n";
    }
}

//========================= Function Implementations ========================//

void dump_text_vkCreateInstance(ApiDumpInstance& dump_inst, VkResult result, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_pointer<const VkInstanceCreateInfo>(pCreateInfo, settings, "const VkInstanceCreateInfo*", "pCreateInfo", 1, dump_text_VkInstanceCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkInstance>(pInstance, settings, "VkInstance*", "pInstance", 1, dump_text_VkInstance);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyInstance(ApiDumpInstance& dump_inst, VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumeratePhysicalDevices(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const uint32_t>(pPhysicalDeviceCount, settings, "uint32_t*", "pPhysicalDeviceCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDevice>(pPhysicalDevices, *pPhysicalDeviceCount, settings, "VkPhysicalDevice*", "VkPhysicalDevice", "pPhysicalDevices", 1, dump_text_VkPhysicalDevice); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceFeatures(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceFeatures>(pFeatures, settings, "VkPhysicalDeviceFeatures*", "pFeatures", 1, dump_text_VkPhysicalDeviceFeatures);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_pointer<const VkFormatProperties>(pFormatProperties, settings, "VkFormatProperties*", "pFormatProperties", 1, dump_text_VkFormatProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_value<const VkImageType>(type, settings, "VkImageType", "type", 1, dump_text_VkImageType); // MET
        dump_text_value<const VkImageTiling>(tiling, settings, "VkImageTiling", "tiling", 1, dump_text_VkImageTiling); // MET
        dump_text_value<const VkImageUsageFlags>(usage, settings, "VkImageUsageFlags", "usage", 1, dump_text_VkImageUsageFlags); // MET
        dump_text_value<const VkImageCreateFlags>(flags, settings, "VkImageCreateFlags", "flags", 1, dump_text_VkImageCreateFlags); // MET
        dump_text_pointer<const VkImageFormatProperties>(pImageFormatProperties, settings, "VkImageFormatProperties*", "pImageFormatProperties", 1, dump_text_VkImageFormatProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceProperties>(pProperties, settings, "VkPhysicalDeviceProperties*", "pProperties", 1, dump_text_VkPhysicalDeviceProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkQueueFamilyProperties>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties*", "VkQueueFamilyProperties", "pQueueFamilyProperties", 1, dump_text_VkQueueFamilyProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceMemoryProperties>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties*", "pMemoryProperties", 1, dump_text_VkPhysicalDeviceMemoryProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDevice(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkDeviceCreateInfo>(pCreateInfo, settings, "const VkDeviceCreateInfo*", "pCreateInfo", 1, dump_text_VkDeviceCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDevice>(pDevice, settings, "VkDevice*", "pDevice", 1, dump_text_VkDevice);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDevice(ApiDumpInstance& dump_inst, VkDevice device, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumerateInstanceExtensionProperties(ApiDumpInstance& dump_inst, VkResult result, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const char*>(pLayerName, settings, "const char*", "pLayerName", 1, dump_text_cstring); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkExtensionProperties>(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "VkExtensionProperties", "pProperties", 1, dump_text_VkExtensionProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumerateDeviceExtensionProperties(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const char*>(pLayerName, settings, "const char*", "pLayerName", 1, dump_text_cstring); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkExtensionProperties>(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "VkExtensionProperties", "pProperties", 1, dump_text_VkExtensionProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumerateInstanceLayerProperties(ApiDumpInstance& dump_inst, VkResult result, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkLayerProperties>(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "VkLayerProperties", "pProperties", 1, dump_text_VkLayerProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumerateDeviceLayerProperties(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkLayerProperties>(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "VkLayerProperties", "pProperties", 1, dump_text_VkLayerProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceQueue(ApiDumpInstance& dump_inst, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queueIndex, settings, "uint32_t", "queueIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkQueue>(pQueue, settings, "VkQueue*", "pQueue", 1, dump_text_VkQueue);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueSubmit(ApiDumpInstance& dump_inst, VkResult result, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_value<const uint32_t>(submitCount, settings, "uint32_t", "submitCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkSubmitInfo>(pSubmits, submitCount, settings, "const VkSubmitInfo*", "const VkSubmitInfo", "pSubmits", 1, dump_text_VkSubmitInfo); // HQA
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueWaitIdle(ApiDumpInstance& dump_inst, VkResult result, VkQueue queue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDeviceWaitIdle(ApiDumpInstance& dump_inst, VkResult result, VkDevice device)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAllocateMemory(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryAllocateInfo>(pAllocateInfo, settings, "const VkMemoryAllocateInfo*", "pAllocateInfo", 1, dump_text_VkMemoryAllocateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDeviceMemory>(pMemory, settings, "VkDeviceMemory*", "pMemory", 1, dump_text_VkDeviceMemory);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkFreeMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkMapMemory(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(size, settings, "VkDeviceSize", "size", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkMemoryMapFlags>(flags, settings, "VkMemoryMapFlags", "flags", 1, dump_text_VkMemoryMapFlags); // MET
        dump_text_pointer<const void*>(ppData, settings, "void**", "ppData", 1, dump_text_void);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUnmapMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkFlushMappedMemoryRanges(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMappedMemoryRange>(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "const VkMappedMemoryRange", "pMemoryRanges", 1, dump_text_VkMappedMemoryRange); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkInvalidateMappedMemoryRanges(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMappedMemoryRange>(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "const VkMappedMemoryRange", "pMemoryRanges", 1, dump_text_VkMappedMemoryRange); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceMemoryCommitment(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_pointer<const VkDeviceSize>(pCommittedMemoryInBytes, settings, "VkDeviceSize*", "pCommittedMemoryInBytes", 1, dump_text_VkDeviceSize);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindBufferMemory(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_value<const VkDeviceSize>(memoryOffset, settings, "VkDeviceSize", "memoryOffset", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindImageMemory(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_value<const VkDeviceSize>(memoryOffset, settings, "VkDeviceSize", "memoryOffset", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_pointer<const VkMemoryRequirements>(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkMemoryRequirements>(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const uint32_t>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageMemoryRequirements>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements*", "VkSparseImageMemoryRequirements", "pSparseMemoryRequirements", 1, dump_text_VkSparseImageMemoryRequirements); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_value<const VkImageType>(type, settings, "VkImageType", "type", 1, dump_text_VkImageType); // MET
        dump_text_value<const VkSampleCountFlagBits>(samples, settings, "VkSampleCountFlagBits", "samples", 1, dump_text_VkSampleCountFlagBits); // MET
        dump_text_value<const VkImageUsageFlags>(usage, settings, "VkImageUsageFlags", "usage", 1, dump_text_VkImageUsageFlags); // MET
        dump_text_value<const VkImageTiling>(tiling, settings, "VkImageTiling", "tiling", 1, dump_text_VkImageTiling); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageFormatProperties>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties*", "VkSparseImageFormatProperties", "pProperties", 1, dump_text_VkSparseImageFormatProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueBindSparse(ApiDumpInstance& dump_inst, VkResult result, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindSparseInfo>(pBindInfo, bindInfoCount, settings, "const VkBindSparseInfo*", "const VkBindSparseInfo", "pBindInfo", 1, dump_text_VkBindSparseInfo); // HQA
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateFence(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkFenceCreateInfo>(pCreateInfo, settings, "const VkFenceCreateInfo*", "pCreateInfo", 1, dump_text_VkFenceCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkFence>(pFence, settings, "VkFence*", "pFence", 1, dump_text_VkFence);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyFence(ApiDumpInstance& dump_inst, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetFences(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(fenceCount, settings, "uint32_t", "fenceCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkFence>(pFences, fenceCount, settings, "const VkFence*", "const VkFence", "pFences", 1, dump_text_VkFence); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetFenceStatus(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkFence fence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWaitForFences(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(fenceCount, settings, "uint32_t", "fenceCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkFence>(pFences, fenceCount, settings, "const VkFence*", "const VkFence", "pFences", 1, dump_text_VkFence); // HQA
        dump_text_value<const VkBool32>(waitAll, settings, "VkBool32", "waitAll", 1, dump_text_VkBool32); // MET
        dump_text_value<const uint64_t>(timeout, settings, "uint64_t", "timeout", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSemaphore(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreCreateInfo>(pCreateInfo, settings, "const VkSemaphoreCreateInfo*", "pCreateInfo", 1, dump_text_VkSemaphoreCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSemaphore>(pSemaphore, settings, "VkSemaphore*", "pSemaphore", 1, dump_text_VkSemaphore);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySemaphore(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSemaphore>(semaphore, settings, "VkSemaphore", "semaphore", 1, dump_text_VkSemaphore); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateEvent(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkEventCreateInfo>(pCreateInfo, settings, "const VkEventCreateInfo*", "pCreateInfo", 1, dump_text_VkEventCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkEvent>(pEvent, settings, "VkEvent*", "pEvent", 1, dump_text_VkEvent);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetEventStatus(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkEvent event)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetEvent(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkEvent event)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetEvent(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkEvent event)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateQueryPool(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkQueryPoolCreateInfo>(pCreateInfo, settings, "const VkQueryPoolCreateInfo*", "pCreateInfo", 1, dump_text_VkQueryPoolCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkQueryPool>(pQueryPool, settings, "VkQueryPool*", "pQueryPool", 1, dump_text_VkQueryPool);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetQueryPoolResults(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queryCount, settings, "uint32_t", "queryCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
        dump_text_value<const VkDeviceSize>(stride, settings, "VkDeviceSize", "stride", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkQueryResultFlags>(flags, settings, "VkQueryResultFlags", "flags", 1, dump_text_VkQueryResultFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateBuffer(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferCreateInfo>(pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", 1, dump_text_VkBufferCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkBuffer>(pBuffer, settings, "VkBuffer*", "pBuffer", 1, dump_text_VkBuffer);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyBuffer(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateBufferView(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferViewCreateInfo>(pCreateInfo, settings, "const VkBufferViewCreateInfo*", "pCreateInfo", 1, dump_text_VkBufferViewCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkBufferView>(pView, settings, "VkBufferView*", "pView", 1, dump_text_VkBufferView);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyBufferView(ApiDumpInstance& dump_inst, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBufferView>(bufferView, settings, "VkBufferView", "bufferView", 1, dump_text_VkBufferView); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateImage(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageCreateInfo>(pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", 1, dump_text_VkImageCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkImage>(pImage, settings, "VkImage*", "pImage", 1, dump_text_VkImage);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyImage(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkImageSubresource>(pSubresource, settings, "const VkImageSubresource*", "pSubresource", 1, dump_text_VkImageSubresource);
        dump_text_pointer<const VkSubresourceLayout>(pLayout, settings, "VkSubresourceLayout*", "pLayout", 1, dump_text_VkSubresourceLayout);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateImageView(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageViewCreateInfo>(pCreateInfo, settings, "const VkImageViewCreateInfo*", "pCreateInfo", 1, dump_text_VkImageViewCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkImageView>(pView, settings, "VkImageView*", "pView", 1, dump_text_VkImageView);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyImageView(ApiDumpInstance& dump_inst, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImageView>(imageView, settings, "VkImageView", "imageView", 1, dump_text_VkImageView); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateShaderModule(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkShaderModuleCreateInfo>(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", 1, dump_text_VkShaderModuleCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkShaderModule>(pShaderModule, settings, "VkShaderModule*", "pShaderModule", 1, dump_text_VkShaderModule);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyShaderModule(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkShaderModule>(shaderModule, settings, "VkShaderModule", "shaderModule", 1, dump_text_VkShaderModule); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreatePipelineCache(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineCacheCreateInfo>(pCreateInfo, settings, "const VkPipelineCacheCreateInfo*", "pCreateInfo", 1, dump_text_VkPipelineCacheCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkPipelineCache>(pPipelineCache, settings, "VkPipelineCache*", "pPipelineCache", 1, dump_text_VkPipelineCache);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPipelineCache(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineCacheData(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_pointer<const size_t>(pDataSize, settings, "size_t*", "pDataSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkMergePipelineCaches(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(dstCache, settings, "VkPipelineCache", "dstCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(srcCacheCount, settings, "uint32_t", "srcCacheCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkPipelineCache>(pSrcCaches, srcCacheCount, settings, "const VkPipelineCache*", "const VkPipelineCache", "pSrcCaches", 1, dump_text_VkPipelineCache); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateGraphicsPipelines(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkGraphicsPipelineCreateInfo>(pCreateInfos, createInfoCount, settings, "const VkGraphicsPipelineCreateInfo*", "const VkGraphicsPipelineCreateInfo", "pCreateInfos", 1, dump_text_VkGraphicsPipelineCreateInfo); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkPipeline>(pPipelines, createInfoCount, settings, "VkPipeline*", "VkPipeline", "pPipelines", 1, dump_text_VkPipeline); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateComputePipelines(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkComputePipelineCreateInfo>(pCreateInfos, createInfoCount, settings, "const VkComputePipelineCreateInfo*", "const VkComputePipelineCreateInfo", "pCreateInfos", 1, dump_text_VkComputePipelineCreateInfo); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkPipeline>(pPipelines, createInfoCount, settings, "VkPipeline*", "VkPipeline", "pPipelines", 1, dump_text_VkPipeline); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPipeline(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreatePipelineLayout(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineLayoutCreateInfo>(pCreateInfo, settings, "const VkPipelineLayoutCreateInfo*", "pCreateInfo", 1, dump_text_VkPipelineLayoutCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkPipelineLayout>(pPipelineLayout, settings, "VkPipelineLayout*", "pPipelineLayout", 1, dump_text_VkPipelineLayout);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPipelineLayout(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineLayout>(pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSampler(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSamplerCreateInfo>(pCreateInfo, settings, "const VkSamplerCreateInfo*", "pCreateInfo", 1, dump_text_VkSamplerCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSampler>(pSampler, settings, "VkSampler*", "pSampler", 1, dump_text_VkSampler);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySampler(ApiDumpInstance& dump_inst, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSampler>(sampler, settings, "VkSampler", "sampler", 1, dump_text_VkSampler); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDescriptorSetLayout(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorSetLayoutCreateInfo>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorSetLayoutCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDescriptorSetLayout>(pSetLayout, settings, "VkDescriptorSetLayout*", "pSetLayout", 1, dump_text_VkDescriptorSetLayout);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDescriptorSetLayout(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSetLayout>(descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", 1, dump_text_VkDescriptorSetLayout); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDescriptorPool(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorPoolCreateInfo>(pCreateInfo, settings, "const VkDescriptorPoolCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorPoolCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDescriptorPool>(pDescriptorPool, settings, "VkDescriptorPool*", "pDescriptorPool", 1, dump_text_VkDescriptorPool);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorPool>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", 1, dump_text_VkDescriptorPool); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetDescriptorPool(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorPool>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", 1, dump_text_VkDescriptorPool); // MET
        dump_text_value<const VkDescriptorPoolResetFlags>(flags, settings, "VkDescriptorPoolResetFlags", "flags", 1, dump_text_VkDescriptorPoolResetFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAllocateDescriptorSets(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorSetAllocateInfo>(pAllocateInfo, settings, "const VkDescriptorSetAllocateInfo*", "pAllocateInfo", 1, dump_text_VkDescriptorSetAllocateInfo);
        dump_text_array<const VkDescriptorSet>(pDescriptorSets, pAllocateInfo->descriptorSetCount, settings, "VkDescriptorSet*", "VkDescriptorSet", "pDescriptorSets", 1, dump_text_VkDescriptorSet); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkFreeDescriptorSets(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorPool>(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", 1, dump_text_VkDescriptorPool); // MET
        dump_text_value<const uint32_t>(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkDescriptorSet>(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "const VkDescriptorSet", "pDescriptorSets", 1, dump_text_VkDescriptorSet); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkWriteDescriptorSet>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "const VkWriteDescriptorSet", "pDescriptorWrites", 1, dump_text_VkWriteDescriptorSet); // HQA
        dump_text_value<const uint32_t>(descriptorCopyCount, settings, "uint32_t", "descriptorCopyCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCopyDescriptorSet>(pDescriptorCopies, descriptorCopyCount, settings, "const VkCopyDescriptorSet*", "const VkCopyDescriptorSet", "pDescriptorCopies", 1, dump_text_VkCopyDescriptorSet); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateFramebuffer(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkFramebufferCreateInfo>(pCreateInfo, settings, "const VkFramebufferCreateInfo*", "pCreateInfo", 1, dump_text_VkFramebufferCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkFramebuffer>(pFramebuffer, settings, "VkFramebuffer*", "pFramebuffer", 1, dump_text_VkFramebuffer);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyFramebuffer(ApiDumpInstance& dump_inst, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkFramebuffer>(framebuffer, settings, "VkFramebuffer", "framebuffer", 1, dump_text_VkFramebuffer); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateRenderPass(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderPassCreateInfo>(pCreateInfo, settings, "const VkRenderPassCreateInfo*", "pCreateInfo", 1, dump_text_VkRenderPassCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkRenderPass>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", 1, dump_text_VkRenderPass);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyRenderPass(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkRenderPass>(renderPass, settings, "VkRenderPass", "renderPass", 1, dump_text_VkRenderPass); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRenderAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkRenderPass>(renderPass, settings, "VkRenderPass", "renderPass", 1, dump_text_VkRenderPass); // MET
        dump_text_pointer<const VkExtent2D>(pGranularity, settings, "VkExtent2D*", "pGranularity", 1, dump_text_VkExtent2D);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateCommandPool(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCommandPoolCreateInfo>(pCreateInfo, settings, "const VkCommandPoolCreateInfo*", "pCreateInfo", 1, dump_text_VkCommandPoolCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkCommandPool>(pCommandPool, settings, "VkCommandPool*", "pCommandPool", 1, dump_text_VkCommandPool);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCommandPool>(commandPool, settings, "VkCommandPool", "commandPool", 1, dump_text_VkCommandPool); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetCommandPool(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCommandPool>(commandPool, settings, "VkCommandPool", "commandPool", 1, dump_text_VkCommandPool); // MET
        dump_text_value<const VkCommandPoolResetFlags>(flags, settings, "VkCommandPoolResetFlags", "flags", 1, dump_text_VkCommandPoolResetFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAllocateCommandBuffers(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCommandBufferAllocateInfo>(pAllocateInfo, settings, "const VkCommandBufferAllocateInfo*", "pAllocateInfo", 1, dump_text_VkCommandBufferAllocateInfo);
        dump_text_array<const VkCommandBuffer>(pCommandBuffers, pAllocateInfo->commandBufferCount, settings, "VkCommandBuffer*", "VkCommandBuffer", "pCommandBuffers", 1, dump_text_VkCommandBuffer); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkFreeCommandBuffers(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCommandPool>(commandPool, settings, "VkCommandPool", "commandPool", 1, dump_text_VkCommandPool); // MET
        dump_text_value<const uint32_t>(commandBufferCount, settings, "uint32_t", "commandBufferCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCommandBuffer>(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "const VkCommandBuffer", "pCommandBuffers", 1, dump_text_VkCommandBuffer); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBeginCommandBuffer(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        ApiDumpInstance::current().setCmdBuffer(commandBuffer);
        dump_text_pointer<const VkCommandBufferBeginInfo>(pBeginInfo, settings, "const VkCommandBufferBeginInfo*", "pBeginInfo", 1, dump_text_VkCommandBufferBeginInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEndCommandBuffer(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetCommandBuffer(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCommandBufferResetFlags>(flags, settings, "VkCommandBufferResetFlags", "flags", 1, dump_text_VkCommandBufferResetFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindPipeline(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewport(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkViewport>(pViewports, viewportCount, settings, "const VkViewport*", "const VkViewport", "pViewports", 1, dump_text_VkViewport); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetScissor(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstScissor, settings, "uint32_t", "firstScissor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRect2D>(pScissors, scissorCount, settings, "const VkRect2D*", "const VkRect2D", "pScissors", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLineWidth(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float lineWidth)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const float>(lineWidth, settings, "float", "lineWidth", 1, dump_text_float); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBias(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const float>(depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", 1, dump_text_float); // MET
        dump_text_value<const float>(depthBiasClamp, settings, "float", "depthBiasClamp", 1, dump_text_float); // MET
        dump_text_value<const float>(depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", 1, dump_text_float); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetBlendConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const float blendConstants[4])
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_array<const float>(blendConstants, 4, settings, "const float[4]", "const float", "blendConstants", 1, dump_text_float); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBounds(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const float>(minDepthBounds, settings, "float", "minDepthBounds", 1, dump_text_float); // MET
        dump_text_value<const float>(maxDepthBounds, settings, "float", "maxDepthBounds", 1, dump_text_float); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilCompareMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkStencilFaceFlags>(faceMask, settings, "VkStencilFaceFlags", "faceMask", 1, dump_text_VkStencilFaceFlags); // MET
        dump_text_value<const uint32_t>(compareMask, settings, "uint32_t", "compareMask", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilWriteMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkStencilFaceFlags>(faceMask, settings, "VkStencilFaceFlags", "faceMask", 1, dump_text_VkStencilFaceFlags); // MET
        dump_text_value<const uint32_t>(writeMask, settings, "uint32_t", "writeMask", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilReference(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkStencilFaceFlags>(faceMask, settings, "VkStencilFaceFlags", "faceMask", 1, dump_text_VkStencilFaceFlags); // MET
        dump_text_value<const uint32_t>(reference, settings, "uint32_t", "reference", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorSets(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(firstSet, settings, "uint32_t", "firstSet", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkDescriptorSet>(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "const VkDescriptorSet", "pDescriptorSets", 1, dump_text_VkDescriptorSet); // HQA
        dump_text_value<const uint32_t>(dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const uint32_t>(pDynamicOffsets, dynamicOffsetCount, settings, "const uint32_t*", "const uint32_t", "pDynamicOffsets", 1, dump_text_uint32_t); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindIndexBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkIndexType>(indexType, settings, "VkIndexType", "indexType", 1, dump_text_VkIndexType); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindVertexBuffers(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pBuffers, bindingCount, settings, "const VkBuffer*", "const VkBuffer", "pBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDraw(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(vertexCount, settings, "uint32_t", "vertexCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstVertex, settings, "uint32_t", "firstVertex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndexed(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(indexCount, settings, "uint32_t", "indexCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstIndex, settings, "uint32_t", "firstIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const int32_t>(vertexOffset, settings, "int32_t", "vertexOffset", 1, dump_text_int32_t); // MET
        dump_text_value<const uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndexedIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDispatch(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDispatchIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(srcBuffer, settings, "VkBuffer", "srcBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBufferCopy>(pRegions, regionCount, settings, "const VkBufferCopy*", "const VkBufferCopy", "pRegions", 1, dump_text_VkBufferCopy); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(srcImage, settings, "VkImage", "srcImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const VkImage>(dstImage, settings, "VkImage", "dstImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageCopy>(pRegions, regionCount, settings, "const VkImageCopy*", "const VkImageCopy", "pRegions", 1, dump_text_VkImageCopy); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBlitImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(srcImage, settings, "VkImage", "srcImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const VkImage>(dstImage, settings, "VkImage", "dstImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageBlit>(pRegions, regionCount, settings, "const VkImageBlit*", "const VkImageBlit", "pRegions", 1, dump_text_VkImageBlit); // HQA
        dump_text_value<const VkFilter>(filter, settings, "VkFilter", "filter", 1, dump_text_VkFilter); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBufferToImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(srcBuffer, settings, "VkBuffer", "srcBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkImage>(dstImage, settings, "VkImage", "dstImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBufferImageCopy>(pRegions, regionCount, settings, "const VkBufferImageCopy*", "const VkBufferImageCopy", "pRegions", 1, dump_text_VkBufferImageCopy); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImageToBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(srcImage, settings, "VkImage", "srcImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBufferImageCopy>(pRegions, regionCount, settings, "const VkBufferImageCopy*", "const VkBufferImageCopy", "pRegions", 1, dump_text_VkBufferImageCopy); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdUpdateBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(dataSize, settings, "VkDeviceSize", "dataSize", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const void*>(pData, settings, "const void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdFillBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(size, settings, "VkDeviceSize", "size", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(data, settings, "uint32_t", "data", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdClearColorImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(imageLayout, settings, "VkImageLayout", "imageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_pointer<const VkClearColorValue>(pColor, settings, "const VkClearColorValue*", "pColor", 1, dump_text_VkClearColorValue);
        dump_text_value<const uint32_t>(rangeCount, settings, "uint32_t", "rangeCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageSubresourceRange>(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "const VkImageSubresourceRange", "pRanges", 1, dump_text_VkImageSubresourceRange); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdClearDepthStencilImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(imageLayout, settings, "VkImageLayout", "imageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_pointer<const VkClearDepthStencilValue>(pDepthStencil, settings, "const VkClearDepthStencilValue*", "pDepthStencil", 1, dump_text_VkClearDepthStencilValue);
        dump_text_value<const uint32_t>(rangeCount, settings, "uint32_t", "rangeCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageSubresourceRange>(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "const VkImageSubresourceRange", "pRanges", 1, dump_text_VkImageSubresourceRange); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdClearAttachments(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkClearAttachment>(pAttachments, attachmentCount, settings, "const VkClearAttachment*", "const VkClearAttachment", "pAttachments", 1, dump_text_VkClearAttachment); // HQA
        dump_text_value<const uint32_t>(rectCount, settings, "uint32_t", "rectCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkClearRect>(pRects, rectCount, settings, "const VkClearRect*", "const VkClearRect", "pRects", 1, dump_text_VkClearRect); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResolveImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImage>(srcImage, settings, "VkImage", "srcImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const VkImage>(dstImage, settings, "VkImage", "dstImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_value<const uint32_t>(regionCount, settings, "uint32_t", "regionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageResolve>(pRegions, regionCount, settings, "const VkImageResolve*", "const VkImageResolve", "pRegions", 1, dump_text_VkImageResolve); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_value<const VkPipelineStageFlags>(stageMask, settings, "VkPipelineStageFlags", "stageMask", 1, dump_text_VkPipelineStageFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_value<const VkPipelineStageFlags>(stageMask, settings, "VkPipelineStageFlags", "stageMask", 1, dump_text_VkPipelineStageFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWaitEvents(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(eventCount, settings, "uint32_t", "eventCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkEvent>(pEvents, eventCount, settings, "const VkEvent*", "const VkEvent", "pEvents", 1, dump_text_VkEvent); // HQA
        dump_text_value<const VkPipelineStageFlags>(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", 1, dump_text_VkPipelineStageFlags); // MET
        dump_text_value<const VkPipelineStageFlags>(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", 1, dump_text_VkPipelineStageFlags); // MET
        dump_text_value<const uint32_t>(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMemoryBarrier>(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "const VkMemoryBarrier", "pMemoryBarriers", 1, dump_text_VkMemoryBarrier); // HQA
        dump_text_value<const uint32_t>(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBufferMemoryBarrier>(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "const VkBufferMemoryBarrier", "pBufferMemoryBarriers", 1, dump_text_VkBufferMemoryBarrier); // HQA
        dump_text_value<const uint32_t>(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageMemoryBarrier>(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "const VkImageMemoryBarrier", "pImageMemoryBarriers", 1, dump_text_VkImageMemoryBarrier); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPipelineBarrier(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlags>(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", 1, dump_text_VkPipelineStageFlags); // MET
        dump_text_value<const VkPipelineStageFlags>(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", 1, dump_text_VkPipelineStageFlags); // MET
        dump_text_value<const VkDependencyFlags>(dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", 1, dump_text_VkDependencyFlags); // MET
        dump_text_value<const uint32_t>(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMemoryBarrier>(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "const VkMemoryBarrier", "pMemoryBarriers", 1, dump_text_VkMemoryBarrier); // HQA
        dump_text_value<const uint32_t>(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBufferMemoryBarrier>(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "const VkBufferMemoryBarrier", "pBufferMemoryBarriers", 1, dump_text_VkBufferMemoryBarrier); // HQA
        dump_text_value<const uint32_t>(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkImageMemoryBarrier>(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "const VkImageMemoryBarrier", "pImageMemoryBarriers", 1, dump_text_VkImageMemoryBarrier); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkQueryControlFlags>(flags, settings, "VkQueryControlFlags", "flags", 1, dump_text_VkQueryControlFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResetQueryPool(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queryCount, settings, "uint32_t", "queryCount", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteTimestamp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlagBits>(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", 1, dump_text_VkPipelineStageFlagBits); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyQueryPoolResults(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queryCount, settings, "uint32_t", "queryCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(stride, settings, "VkDeviceSize", "stride", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkQueryResultFlags>(flags, settings, "VkQueryResultFlags", "flags", 1, dump_text_VkQueryResultFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const VkShaderStageFlags>(stageFlags, settings, "VkShaderStageFlags", "stageFlags", 1, dump_text_VkShaderStageFlags); // MET
        dump_text_value<const uint32_t>(offset, settings, "uint32_t", "offset", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(size, settings, "uint32_t", "size", 1, dump_text_uint32_t); // MET
        dump_text_value<const void*>(pValues, settings, "const void*", "pValues", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderPassBeginInfo>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", 1, dump_text_VkRenderPassBeginInfo);
        dump_text_value<const VkSubpassContents>(contents, settings, "VkSubpassContents", "contents", 1, dump_text_VkSubpassContents); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdNextSubpass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSubpassContents contents)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkSubpassContents>(contents, settings, "VkSubpassContents", "contents", 1, dump_text_VkSubpassContents); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdExecuteCommands(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(commandBufferCount, settings, "uint32_t", "commandBufferCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCommandBuffer>(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "const VkCommandBuffer", "pCommandBuffers", 1, dump_text_VkCommandBuffer); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindBufferMemory2(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindBufferMemoryInfo>(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "const VkBindBufferMemoryInfo", "pBindInfos", 1, dump_text_VkBindBufferMemoryInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindImageMemory2(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindImageMemoryInfo>(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "const VkBindImageMemoryInfo", "pBindInfos", 1, dump_text_VkBindImageMemoryInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(heapIndex, settings, "uint32_t", "heapIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkPeerMemoryFeatureFlags>(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", 1, dump_text_VkPeerMemoryFeatureFlags);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDeviceMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(deviceMask, settings, "uint32_t", "deviceMask", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDispatchBase(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(baseGroupX, settings, "uint32_t", "baseGroupX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(baseGroupY, settings, "uint32_t", "baseGroupY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(baseGroupZ, settings, "uint32_t", "baseGroupZ", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const uint32_t>(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDeviceGroupProperties>(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "VkPhysicalDeviceGroupProperties", "pPhysicalDeviceGroupProperties", 1, dump_text_VkPhysicalDeviceGroupProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageMemoryRequirementsInfo2>(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkImageMemoryRequirementsInfo2);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferMemoryRequirementsInfo2>(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkBufferMemoryRequirementsInfo2);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSparseMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageSparseMemoryRequirementsInfo2>(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkImageSparseMemoryRequirementsInfo2);
        dump_text_pointer<const uint32_t>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageMemoryRequirements2>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "VkSparseImageMemoryRequirements2", "pSparseMemoryRequirements", 1, dump_text_VkSparseImageMemoryRequirements2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceFeatures2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceFeatures2>(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", 1, dump_text_VkPhysicalDeviceFeatures2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceProperties2>(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", 1, dump_text_VkPhysicalDeviceProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_pointer<const VkFormatProperties2>(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", 1, dump_text_VkFormatProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceImageFormatInfo2>(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", 1, dump_text_VkPhysicalDeviceImageFormatInfo2);
        dump_text_pointer<const VkImageFormatProperties2>(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", 1, dump_text_VkImageFormatProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkQueueFamilyProperties2>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "VkQueueFamilyProperties2", "pQueueFamilyProperties", 1, dump_text_VkQueueFamilyProperties2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceMemoryProperties2>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", 1, dump_text_VkPhysicalDeviceMemoryProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSparseImageFormatInfo2>(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", 1, dump_text_VkPhysicalDeviceSparseImageFormatInfo2);
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageFormatProperties2>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "VkSparseImageFormatProperties2", "pProperties", 1, dump_text_VkSparseImageFormatProperties2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkTrimCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCommandPool>(commandPool, settings, "VkCommandPool", "commandPool", 1, dump_text_VkCommandPool); // MET
        dump_text_value<const VkCommandPoolTrimFlags>(flags, settings, "VkCommandPoolTrimFlags", "flags", 1, dump_text_VkCommandPoolTrimFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceQueue2(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceQueueInfo2>(pQueueInfo, settings, "const VkDeviceQueueInfo2*", "pQueueInfo", 1, dump_text_VkDeviceQueueInfo2);
        dump_text_pointer<const VkQueue>(pQueue, settings, "VkQueue*", "pQueue", 1, dump_text_VkQueue);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSamplerYcbcrConversionCreateInfo>(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", 1, dump_text_VkSamplerYcbcrConversionCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSamplerYcbcrConversion>(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", 1, dump_text_VkSamplerYcbcrConversion);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSamplerYcbcrConversion>(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", 1, dump_text_VkSamplerYcbcrConversion); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorUpdateTemplateCreateInfo>(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorUpdateTemplateCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDescriptorUpdateTemplate>(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSet>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", 1, dump_text_VkDescriptorSet); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_value<const void*>(pData, settings, "const void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalBufferInfo>(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", 1, dump_text_VkPhysicalDeviceExternalBufferInfo);
        dump_text_pointer<const VkExternalBufferProperties>(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", 1, dump_text_VkExternalBufferProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalFenceInfo>(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", 1, dump_text_VkPhysicalDeviceExternalFenceInfo);
        dump_text_pointer<const VkExternalFenceProperties>(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", 1, dump_text_VkExternalFenceProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalSemaphoreInfo>(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", 1, dump_text_VkPhysicalDeviceExternalSemaphoreInfo);
        dump_text_pointer<const VkExternalSemaphoreProperties>(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", 1, dump_text_VkExternalSemaphoreProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetLayoutSupport(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorSetLayoutCreateInfo>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorSetLayoutCreateInfo);
        dump_text_pointer<const VkDescriptorSetLayoutSupport>(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", 1, dump_text_VkDescriptorSetLayoutSupport);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndexedIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateRenderPass2(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderPassCreateInfo2>(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", 1, dump_text_VkRenderPassCreateInfo2);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkRenderPass>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", 1, dump_text_VkRenderPass);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderPassBeginInfo>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", 1, dump_text_VkRenderPassBeginInfo);
        dump_text_pointer<const VkSubpassBeginInfo>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", 1, dump_text_VkSubpassBeginInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdNextSubpass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSubpassBeginInfo>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", 1, dump_text_VkSubpassBeginInfo);
        dump_text_pointer<const VkSubpassEndInfo>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", 1, dump_text_VkSubpassEndInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSubpassEndInfo>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", 1, dump_text_VkSubpassEndInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queryCount, settings, "uint32_t", "queryCount", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSemaphoreCounterValue(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSemaphore>(semaphore, settings, "VkSemaphore", "semaphore", 1, dump_text_VkSemaphore); // MET
        dump_text_pointer<const uint64_t>(pValue, settings, "uint64_t*", "pValue", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWaitSemaphores(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreWaitInfo>(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", 1, dump_text_VkSemaphoreWaitInfo);
        dump_text_value<const uint64_t>(timeout, settings, "uint64_t", "timeout", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSignalSemaphore(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreSignalInfo>(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", 1, dump_text_VkSemaphoreSignalInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferDeviceAddress(ApiDumpInstance& dump_inst, VkDeviceAddress result, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceAddress(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferDeviceAddressInfo>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", 1, dump_text_VkBufferDeviceAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance& dump_inst, uint64_t result, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint64_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferDeviceAddressInfo>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", 1, dump_text_VkBufferDeviceAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance& dump_inst, uint64_t result, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint64_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceMemoryOpaqueCaptureAddressInfo>(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", 1, dump_text_VkDeviceMemoryOpaqueCaptureAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceToolProperties(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pToolCount, settings, "uint32_t*", "pToolCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDeviceToolProperties>(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "VkPhysicalDeviceToolProperties", "pToolProperties", 1, dump_text_VkPhysicalDeviceToolProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreatePrivateDataSlot(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPrivateDataSlotCreateInfo>(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", 1, dump_text_VkPrivateDataSlotCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkPrivateDataSlot>(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", 1, dump_text_VkPrivateDataSlot);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPrivateDataSlot(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetPrivateData(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkObjectType>(objectType, settings, "VkObjectType", "objectType", 1, dump_text_VkObjectType); // MET
        dump_text_value<const uint64_t>(objectHandle, settings, "uint64_t", "objectHandle", 1, dump_text_uint64_t); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_value<const uint64_t>(data, settings, "uint64_t", "data", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPrivateData(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkObjectType>(objectType, settings, "VkObjectType", "objectType", 1, dump_text_VkObjectType); // MET
        dump_text_value<const uint64_t>(objectHandle, settings, "uint64_t", "objectHandle", 1, dump_text_uint64_t); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_pointer<const uint64_t>(pData, settings, "uint64_t*", "pData", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfo*                             pDependencyInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_pointer<const VkDependencyInfo>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", 1, dump_text_VkDependencyInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2               stageMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_value<const VkPipelineStageFlags2>(stageMask, settings, "VkPipelineStageFlags2", "stageMask", 1, dump_text_VkPipelineStageFlags2); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWaitEvents2(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfo*            pDependencyInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(eventCount, settings, "uint32_t", "eventCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkEvent>(pEvents, eventCount, settings, "const VkEvent*", "const VkEvent", "pEvents", 1, dump_text_VkEvent); // HQA
        dump_text_array<const VkDependencyInfo>(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "const VkDependencyInfo", "pDependencyInfos", 1, dump_text_VkDependencyInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPipelineBarrier2(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, const VkDependencyInfo*                             pDependencyInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDependencyInfo>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", 1, dump_text_VkDependencyInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteTimestamp2(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2               stage, VkQueryPool                                         queryPool, uint32_t                                            query)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlags2>(stage, settings, "VkPipelineStageFlags2", "stage", 1, dump_text_VkPipelineStageFlags2); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueSubmit2(ApiDumpInstance& dump_inst, VkResult result, VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2*              pSubmits, VkFence           fence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_value<const uint32_t>(submitCount, settings, "uint32_t", "submitCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkSubmitInfo2>(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "const VkSubmitInfo2", "pSubmits", 1, dump_text_VkSubmitInfo2); // HQA
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyBufferInfo2>(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", 1, dump_text_VkCopyBufferInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyImageInfo2>(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", 1, dump_text_VkCopyImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBufferToImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyBufferToImageInfo2>(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", 1, dump_text_VkCopyBufferToImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImageToBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyImageToBufferInfo2>(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", 1, dump_text_VkCopyImageToBufferInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBlitImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBlitImageInfo2>(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", 1, dump_text_VkBlitImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResolveImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkResolveImageInfo2>(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", 1, dump_text_VkResolveImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginRendering(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, const VkRenderingInfo*                              pRenderingInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingInfo>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", 1, dump_text_VkRenderingInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndRendering(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCullMode(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCullModeFlags>(cullMode, settings, "VkCullModeFlags", "cullMode", 1, dump_text_VkCullModeFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetFrontFace(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkFrontFace>(frontFace, settings, "VkFrontFace", "frontFace", 1, dump_text_VkFrontFace); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPrimitiveTopology(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPrimitiveTopology>(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", 1, dump_text_VkPrimitiveTopology); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkViewport>(pViewports, viewportCount, settings, "const VkViewport*", "const VkViewport", "pViewports", 1, dump_text_VkViewport); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetScissorWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRect2D>(pScissors, scissorCount, settings, "const VkRect2D*", "const VkRect2D", "pScissors", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindVertexBuffers2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pBuffers, bindingCount, settings, "const VkBuffer*", "const VkBuffer", "pBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", 1, dump_text_VkDeviceSize); // HQA
        dump_text_array<const VkDeviceSize>(pSizes, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pSizes", 1, dump_text_VkDeviceSize); // HQA
        dump_text_array<const VkDeviceSize>(pStrides, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pStrides", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthTestEnable, settings, "VkBool32", "depthTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthWriteEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthCompareOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCompareOp>(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", 1, dump_text_VkCompareOp); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkStencilFaceFlags>(faceMask, settings, "VkStencilFaceFlags", "faceMask", 1, dump_text_VkStencilFaceFlags); // MET
        dump_text_value<const VkStencilOp>(failOp, settings, "VkStencilOp", "failOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkStencilOp>(passOp, settings, "VkStencilOp", "passOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkStencilOp>(depthFailOp, settings, "VkStencilOp", "depthFailOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkCompareOp>(compareOp, settings, "VkCompareOp", "compareOp", 1, dump_text_VkCompareOp); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBiasEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceBufferMemoryRequirements>(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceBufferMemoryRequirements);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageMemoryRequirements>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceImageMemoryRequirements);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageMemoryRequirements>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceImageMemoryRequirements);
        dump_text_pointer<const uint32_t>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageMemoryRequirements2>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "VkSparseImageMemoryRequirements2", "pSparseMemoryRequirements", 1, dump_text_VkSparseImageMemoryRequirements2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLineStipple(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", 1, dump_text_uint16_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkMapMemory2(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryMapInfo>(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", 1, dump_text_VkMemoryMapInfo);
        dump_text_pointer<const void*>(ppData, settings, "void**", "ppData", 1, dump_text_void);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUnmapMemory2(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryUnmapInfo>(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", 1, dump_text_VkMemoryUnmapInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindIndexBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(size, settings, "VkDeviceSize", "size", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkIndexType>(indexType, settings, "VkIndexType", "indexType", 1, dump_text_VkIndexType); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRenderingAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderingAreaInfo>(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", 1, dump_text_VkRenderingAreaInfo);
        dump_text_pointer<const VkExtent2D>(pGranularity, settings, "VkExtent2D*", "pGranularity", 1, dump_text_VkExtent2D);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageSubresourceInfo>(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", 1, dump_text_VkDeviceImageSubresourceInfo);
        dump_text_pointer<const VkSubresourceLayout2>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", 1, dump_text_VkSubresourceLayout2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSubresourceLayout2(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkImageSubresource2>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", 1, dump_text_VkImageSubresource2);
        dump_text_pointer<const VkSubresourceLayout2>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", 1, dump_text_VkSubresourceLayout2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSet(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(set, settings, "uint32_t", "set", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkWriteDescriptorSet>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "const VkWriteDescriptorSet", "pDescriptorWrites", 1, dump_text_VkWriteDescriptorSet); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(set, settings, "uint32_t", "set", 1, dump_text_uint32_t); // MET
        dump_text_value<const void*>(pData, settings, "const void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingAttachmentLocationInfo>(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", 1, dump_text_VkRenderingAttachmentLocationInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingInputAttachmentIndexInfo>(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", 1, dump_text_VkRenderingInputAttachmentIndexInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorSets2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo*   pBindDescriptorSetsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBindDescriptorSetsInfo>(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", 1, dump_text_VkBindDescriptorSetsInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushConstants2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo*        pPushConstantsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushConstantsInfo>(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", 1, dump_text_VkPushConstantsInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSet2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo*    pPushDescriptorSetInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushDescriptorSetInfo>(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", 1, dump_text_VkPushDescriptorSetInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushDescriptorSetWithTemplateInfo>(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", 1, dump_text_VkPushDescriptorSetWithTemplateInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMemoryToImage(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyMemoryToImageInfo*    pCopyMemoryToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyMemoryToImageInfo>(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", 1, dump_text_VkCopyMemoryToImageInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyImageToMemory(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyImageToMemoryInfo*    pCopyImageToMemoryInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyImageToMemoryInfo>(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", 1, dump_text_VkCopyImageToMemoryInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyImageToImage(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyImageToImageInfo*    pCopyImageToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyImageToImageInfo>(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", 1, dump_text_VkCopyImageToImageInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkTransitionImageLayout(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo*    pTransitions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(transitionCount, settings, "uint32_t", "transitionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkHostImageLayoutTransitionInfo>(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "const VkHostImageLayoutTransitionInfo", "pTransitions", 1, dump_text_VkHostImageLayoutTransitionInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const VkBool32>(pSupported, settings, "VkBool32*", "pSupported", 1, dump_text_VkBool32);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const VkSurfaceCapabilitiesKHR>(pSurfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR*", "pSurfaceCapabilities", 1, dump_text_VkSurfaceCapabilitiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const uint32_t>(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSurfaceFormatKHR>(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormatKHR*", "VkSurfaceFormatKHR", "pSurfaceFormats", 1, dump_text_VkSurfaceFormatKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const uint32_t>(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPresentModeKHR>(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "VkPresentModeKHR", "pPresentModes", 1, dump_text_VkPresentModeKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSwapchainKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSwapchainCreateInfoKHR>(pCreateInfo, settings, "const VkSwapchainCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkSwapchainCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSwapchainKHR>(pSwapchain, settings, "VkSwapchainKHR*", "pSwapchain", 1, dump_text_VkSwapchainKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySwapchainKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSwapchainImagesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const uint32_t>(pSwapchainImageCount, settings, "uint32_t*", "pSwapchainImageCount", 1, dump_text_uint32_t);
        dump_text_array<const VkImage>(pSwapchainImages, *pSwapchainImageCount, settings, "VkImage*", "VkImage", "pSwapchainImages", 1, dump_text_VkImage); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAcquireNextImageKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_value<const uint64_t>(timeout, settings, "uint64_t", "timeout", 1, dump_text_uint64_t); // MET
        dump_text_value<const VkSemaphore>(semaphore, settings, "VkSemaphore", "semaphore", 1, dump_text_VkSemaphore); // MET
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
        dump_text_pointer<const uint32_t>(pImageIndex, settings, "uint32_t*", "pImageIndex", 1, dump_text_uint32_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueuePresentKHR(ApiDumpInstance& dump_inst, VkResult result, VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const VkPresentInfoKHR>(pPresentInfo, settings, "const VkPresentInfoKHR*", "pPresentInfo", 1, dump_text_VkPresentInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceGroupPresentCapabilitiesKHR>(pDeviceGroupPresentCapabilities, settings, "VkDeviceGroupPresentCapabilitiesKHR*", "pDeviceGroupPresentCapabilities", 1, dump_text_VkDeviceGroupPresentCapabilitiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const VkDeviceGroupPresentModeFlagsKHR>(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", 1, dump_text_VkDeviceGroupPresentModeFlagsKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const uint32_t>(pRectCount, settings, "uint32_t*", "pRectCount", 1, dump_text_uint32_t);
        dump_text_array<const VkRect2D>(pRects, *pRectCount, settings, "VkRect2D*", "VkRect2D", "pRects", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAcquireNextImage2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAcquireNextImageInfoKHR>(pAcquireInfo, settings, "const VkAcquireNextImageInfoKHR*", "pAcquireInfo", 1, dump_text_VkAcquireNextImageInfoKHR);
        dump_text_pointer<const uint32_t>(pImageIndex, settings, "uint32_t*", "pImageIndex", 1, dump_text_uint32_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayPropertiesKHR>(pProperties, *pPropertyCount, settings, "VkDisplayPropertiesKHR*", "VkDisplayPropertiesKHR", "pProperties", 1, dump_text_VkDisplayPropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayPlanePropertiesKHR>(pProperties, *pPropertyCount, settings, "VkDisplayPlanePropertiesKHR*", "VkDisplayPlanePropertiesKHR", "pProperties", 1, dump_text_VkDisplayPlanePropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(planeIndex, settings, "uint32_t", "planeIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const uint32_t>(pDisplayCount, settings, "uint32_t*", "pDisplayCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayKHR>(pDisplays, *pDisplayCount, settings, "VkDisplayKHR*", "VkDisplayKHR", "pDisplays", 1, dump_text_VkDisplayKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDisplayModePropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayModePropertiesKHR>(pProperties, *pPropertyCount, settings, "VkDisplayModePropertiesKHR*", "VkDisplayModePropertiesKHR", "pProperties", 1, dump_text_VkDisplayModePropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDisplayModeKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
        dump_text_pointer<const VkDisplayModeCreateInfoKHR>(pCreateInfo, settings, "const VkDisplayModeCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkDisplayModeCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDisplayModeKHR>(pMode, settings, "VkDisplayModeKHR*", "pMode", 1, dump_text_VkDisplayModeKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayModeKHR>(mode, settings, "VkDisplayModeKHR", "mode", 1, dump_text_VkDisplayModeKHR); // MET
        dump_text_value<const uint32_t>(planeIndex, settings, "uint32_t", "planeIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkDisplayPlaneCapabilitiesKHR>(pCapabilities, settings, "VkDisplayPlaneCapabilitiesKHR*", "pCapabilities", 1, dump_text_VkDisplayPlaneCapabilitiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkDisplaySurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkDisplaySurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkDisplaySurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSharedSwapchainsKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(swapchainCount, settings, "uint32_t", "swapchainCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkSwapchainCreateInfoKHR>(pCreateInfos, swapchainCount, settings, "const VkSwapchainCreateInfoKHR*", "const VkSwapchainCreateInfoKHR", "pCreateInfos", 1, dump_text_VkSwapchainCreateInfoKHR); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkSwapchainKHR>(pSwapchains, swapchainCount, settings, "VkSwapchainKHR*", "VkSwapchainKHR", "pSwapchains", 1, dump_text_VkSwapchainKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_vkCreateXlibSurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkXlibSurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkXlibSurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkXlibSurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XLIB_KHR)
void dump_text_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const Display*>(dpy, settings, "Display*", "dpy", 1, dump_text_Display); // MET
        dump_text_value<const VisualID>(visualID, settings, "VisualID", "visualID", 1, dump_text_VisualID); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XLIB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_vkCreateXcbSurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkXcbSurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkXcbSurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkXcbSurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_XCB_KHR)
void dump_text_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const xcb_connection_t*>(connection, settings, "xcb_connection_t*", "connection", 1, dump_text_xcb_connection_t); // MET
        dump_text_value<const xcb_visualid_t>(visual_id, settings, "xcb_visualid_t", "visual_id", 1, dump_text_xcb_visualid_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XCB_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_vkCreateWaylandSurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkWaylandSurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkWaylandSurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkWaylandSurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
void dump_text_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const wl_display*>(display, settings, "struct wl_display*", "display", 1, dump_text_wl_display); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_vkCreateAndroidSurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkAndroidSurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkAndroidSurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkAndroidSurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkCreateWin32SurfaceKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkWin32SurfaceCreateInfoKHR>(pCreateInfo, settings, "const VkWin32SurfaceCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkWin32SurfaceCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkCreateDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkDebugReportCallbackCreateInfoEXT>(pCreateInfo, settings, "const VkDebugReportCallbackCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkDebugReportCallbackCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDebugReportCallbackEXT>(pCallback, settings, "VkDebugReportCallbackEXT*", "pCallback", 1, dump_text_VkDebugReportCallbackEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_value<const VkDebugReportCallbackEXT>(callback, settings, "VkDebugReportCallbackEXT", "callback", 1, dump_text_VkDebugReportCallbackEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDebugReportMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_value<const VkDebugReportFlagsEXT>(flags, settings, "VkDebugReportFlagsEXT", "flags", 1, dump_text_VkDebugReportFlagsEXT); // MET
        dump_text_value<const VkDebugReportObjectTypeEXT>(objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", 1, dump_text_VkDebugReportObjectTypeEXT); // MET
        dump_text_value<const uint64_t>(object, settings, "uint64_t", "object", 1, dump_text_uint64_t); // MET
        dump_text_value<const size_t>(location, settings, "size_t", "location", 1, dump_text_size_t); // MET
        dump_text_value<const int32_t>(messageCode, settings, "int32_t", "messageCode", 1, dump_text_int32_t); // MET
        dump_text_value<const char*>(pLayerPrefix, settings, "const char*", "pLayerPrefix", 1, dump_text_cstring); // MET
        dump_text_value<const char*>(pMessage, settings, "const char*", "pMessage", 1, dump_text_cstring); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDebugMarkerObjectTagInfoEXT>(pTagInfo, settings, "const VkDebugMarkerObjectTagInfoEXT*", "pTagInfo", 1, dump_text_VkDebugMarkerObjectTagInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDebugMarkerObjectNameInfoEXT>(pNameInfo, settings, "const VkDebugMarkerObjectNameInfoEXT*", "pNameInfo", 1, dump_text_VkDebugMarkerObjectNameInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDebugMarkerBeginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDebugMarkerMarkerInfoEXT>(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", 1, dump_text_VkDebugMarkerMarkerInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDebugMarkerEndEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDebugMarkerInsertEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDebugMarkerMarkerInfoEXT>(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", 1, dump_text_VkDebugMarkerMarkerInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkVideoProfileInfoKHR>(pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", 1, dump_text_VkVideoProfileInfoKHR);
        dump_text_pointer<const VkVideoCapabilitiesKHR>(pCapabilities, settings, "VkVideoCapabilitiesKHR*", "pCapabilities", 1, dump_text_VkVideoCapabilitiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceVideoFormatInfoKHR>(pVideoFormatInfo, settings, "const VkPhysicalDeviceVideoFormatInfoKHR*", "pVideoFormatInfo", 1, dump_text_VkPhysicalDeviceVideoFormatInfoKHR);
        dump_text_pointer<const uint32_t>(pVideoFormatPropertyCount, settings, "uint32_t*", "pVideoFormatPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkVideoFormatPropertiesKHR>(pVideoFormatProperties, *pVideoFormatPropertyCount, settings, "VkVideoFormatPropertiesKHR*", "VkVideoFormatPropertiesKHR", "pVideoFormatProperties", 1, dump_text_VkVideoFormatPropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateVideoSessionKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkVideoSessionCreateInfoKHR>(pCreateInfo, settings, "const VkVideoSessionCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkVideoSessionCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkVideoSessionKHR>(pVideoSession, settings, "VkVideoSessionKHR*", "pVideoSession", 1, dump_text_VkVideoSessionKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyVideoSessionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkVideoSessionKHR>(videoSession, settings, "VkVideoSessionKHR", "videoSession", 1, dump_text_VkVideoSessionKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkVideoSessionKHR>(videoSession, settings, "VkVideoSessionKHR", "videoSession", 1, dump_text_VkVideoSessionKHR); // MET
        dump_text_pointer<const uint32_t>(pMemoryRequirementsCount, settings, "uint32_t*", "pMemoryRequirementsCount", 1, dump_text_uint32_t);
        dump_text_array<const VkVideoSessionMemoryRequirementsKHR>(pMemoryRequirements, *pMemoryRequirementsCount, settings, "VkVideoSessionMemoryRequirementsKHR*", "VkVideoSessionMemoryRequirementsKHR", "pMemoryRequirements", 1, dump_text_VkVideoSessionMemoryRequirementsKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindVideoSessionMemoryKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkVideoSessionKHR>(videoSession, settings, "VkVideoSessionKHR", "videoSession", 1, dump_text_VkVideoSessionKHR); // MET
        dump_text_value<const uint32_t>(bindSessionMemoryInfoCount, settings, "uint32_t", "bindSessionMemoryInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindVideoSessionMemoryInfoKHR>(pBindSessionMemoryInfos, bindSessionMemoryInfoCount, settings, "const VkBindVideoSessionMemoryInfoKHR*", "const VkBindVideoSessionMemoryInfoKHR", "pBindSessionMemoryInfos", 1, dump_text_VkBindVideoSessionMemoryInfoKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkVideoSessionParametersCreateInfoKHR>(pCreateInfo, settings, "const VkVideoSessionParametersCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkVideoSessionParametersCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkVideoSessionParametersKHR>(pVideoSessionParameters, settings, "VkVideoSessionParametersKHR*", "pVideoSessionParameters", 1, dump_text_VkVideoSessionParametersKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkVideoSessionParametersKHR>(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", 1, dump_text_VkVideoSessionParametersKHR); // MET
        dump_text_pointer<const VkVideoSessionParametersUpdateInfoKHR>(pUpdateInfo, settings, "const VkVideoSessionParametersUpdateInfoKHR*", "pUpdateInfo", 1, dump_text_VkVideoSessionParametersUpdateInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkVideoSessionParametersKHR>(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", 1, dump_text_VkVideoSessionParametersKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkVideoBeginCodingInfoKHR>(pBeginInfo, settings, "const VkVideoBeginCodingInfoKHR*", "pBeginInfo", 1, dump_text_VkVideoBeginCodingInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkVideoEndCodingInfoKHR>(pEndCodingInfo, settings, "const VkVideoEndCodingInfoKHR*", "pEndCodingInfo", 1, dump_text_VkVideoEndCodingInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdControlVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkVideoCodingControlInfoKHR>(pCodingControlInfo, settings, "const VkVideoCodingControlInfoKHR*", "pCodingControlInfo", 1, dump_text_VkVideoCodingControlInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDecodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkVideoDecodeInfoKHR>(pDecodeInfo, settings, "const VkVideoDecodeInfoKHR*", "pDecodeInfo", 1, dump_text_VkVideoDecodeInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pBuffers, bindingCount, settings, "const VkBuffer*", "const VkBuffer", "pBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", 1, dump_text_VkDeviceSize); // HQA
        dump_text_array<const VkDeviceSize>(pSizes, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pSizes", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(counterBufferCount, settings, "uint32_t", "counterBufferCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "const VkBuffer", "pCounterBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pCounterBufferOffsets", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(counterBufferCount, settings, "uint32_t", "counterBufferCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "const VkBuffer", "pCounterBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pCounterBufferOffsets", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkQueryControlFlags>(flags, settings, "VkQueryControlFlags", "flags", 1, dump_text_VkQueryControlFlags); // MET
        dump_text_value<const uint32_t>(index, settings, "uint32_t", "index", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(index, settings, "uint32_t", "index", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkBuffer>(counterBuffer, settings, "VkBuffer", "counterBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(counterBufferOffset, settings, "VkDeviceSize", "counterBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(counterOffset, settings, "uint32_t", "counterOffset", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(vertexStride, settings, "uint32_t", "vertexStride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateCuModuleNVX(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCuModuleCreateInfoNVX>(pCreateInfo, settings, "const VkCuModuleCreateInfoNVX*", "pCreateInfo", 1, dump_text_VkCuModuleCreateInfoNVX);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkCuModuleNVX>(pModule, settings, "VkCuModuleNVX*", "pModule", 1, dump_text_VkCuModuleNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateCuFunctionNVX(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCuFunctionCreateInfoNVX>(pCreateInfo, settings, "const VkCuFunctionCreateInfoNVX*", "pCreateInfo", 1, dump_text_VkCuFunctionCreateInfoNVX);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkCuFunctionNVX>(pFunction, settings, "VkCuFunctionNVX*", "pFunction", 1, dump_text_VkCuFunctionNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyCuModuleNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCuModuleNVX>(module, settings, "VkCuModuleNVX", "module", 1, dump_text_VkCuModuleNVX); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyCuFunctionNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCuFunctionNVX>(function, settings, "VkCuFunctionNVX", "function", 1, dump_text_VkCuFunctionNVX); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCuLaunchKernelNVX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCuLaunchInfoNVX>(pLaunchInfo, settings, "const VkCuLaunchInfoNVX*", "pLaunchInfo", 1, dump_text_VkCuLaunchInfoNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageViewHandleNVX(ApiDumpInstance& dump_inst, uint32_t result, VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint32_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageViewHandleInfoNVX>(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", 1, dump_text_VkImageViewHandleInfoNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageViewHandle64NVX(ApiDumpInstance& dump_inst, uint64_t result, VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint64_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageViewHandleInfoNVX>(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", 1, dump_text_VkImageViewHandleInfoNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageViewAddressNVX(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImageView>(imageView, settings, "VkImageView", "imageView", 1, dump_text_VkImageView); // MET
        dump_text_pointer<const VkImageViewAddressPropertiesNVX>(pProperties, settings, "VkImageViewAddressPropertiesNVX*", "pProperties", 1, dump_text_VkImageViewAddressPropertiesNVX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetShaderInfoAMD(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const VkShaderStageFlagBits>(shaderStage, settings, "VkShaderStageFlagBits", "shaderStage", 1, dump_text_VkShaderStageFlagBits); // MET
        dump_text_value<const VkShaderInfoTypeAMD>(infoType, settings, "VkShaderInfoTypeAMD", "infoType", 1, dump_text_VkShaderInfoTypeAMD); // MET
        dump_text_pointer<const size_t>(pInfoSize, settings, "size_t*", "pInfoSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pInfo, settings, "void*", "pInfo", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, const VkRenderingInfo*                              pRenderingInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingInfo>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", 1, dump_text_VkRenderingInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_GGP)
void dump_text_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkStreamDescriptorSurfaceCreateInfoGGP>(pCreateInfo, settings, "const VkStreamDescriptorSurfaceCreateInfoGGP*", "pCreateInfo", 1, dump_text_VkStreamDescriptorSurfaceCreateInfoGGP);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_GGP
void dump_text_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_value<const VkImageType>(type, settings, "VkImageType", "type", 1, dump_text_VkImageType); // MET
        dump_text_value<const VkImageTiling>(tiling, settings, "VkImageTiling", "tiling", 1, dump_text_VkImageTiling); // MET
        dump_text_value<const VkImageUsageFlags>(usage, settings, "VkImageUsageFlags", "usage", 1, dump_text_VkImageUsageFlags); // MET
        dump_text_value<const VkImageCreateFlags>(flags, settings, "VkImageCreateFlags", "flags", 1, dump_text_VkImageCreateFlags); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(externalHandleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "externalHandleType", 1, dump_text_VkExternalMemoryHandleTypeFlagsNV); // MET
        dump_text_pointer<const VkExternalImageFormatPropertiesNV>(pExternalImageFormatProperties, settings, "VkExternalImageFormatPropertiesNV*", "pExternalImageFormatProperties", 1, dump_text_VkExternalImageFormatPropertiesNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetMemoryWin32HandleNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagsNV>(handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagsNV); // MET
        dump_text_pointer<const HANDLE>(pHandle, settings, "HANDLE*", "pHandle", 1, dump_text_HANDLE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceFeatures2>(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", 1, dump_text_VkPhysicalDeviceFeatures2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceProperties2>(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", 1, dump_text_VkPhysicalDeviceProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkFormat>(format, settings, "VkFormat", "format", 1, dump_text_VkFormat); // MET
        dump_text_pointer<const VkFormatProperties2>(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", 1, dump_text_VkFormatProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceImageFormatInfo2>(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", 1, dump_text_VkPhysicalDeviceImageFormatInfo2);
        dump_text_pointer<const VkImageFormatProperties2>(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", 1, dump_text_VkImageFormatProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkQueueFamilyProperties2>(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "VkQueueFamilyProperties2", "pQueueFamilyProperties", 1, dump_text_VkQueueFamilyProperties2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceMemoryProperties2>(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", 1, dump_text_VkPhysicalDeviceMemoryProperties2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSparseImageFormatInfo2>(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", 1, dump_text_VkPhysicalDeviceSparseImageFormatInfo2);
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageFormatProperties2>(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "VkSparseImageFormatProperties2", "pProperties", 1, dump_text_VkSparseImageFormatProperties2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(heapIndex, settings, "uint32_t", "heapIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkPeerMemoryFeatureFlags>(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", 1, dump_text_VkPeerMemoryFeatureFlags);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDeviceMaskKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(deviceMask, settings, "uint32_t", "deviceMask", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDispatchBaseKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(baseGroupX, settings, "uint32_t", "baseGroupX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(baseGroupY, settings, "uint32_t", "baseGroupY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(baseGroupZ, settings, "uint32_t", "baseGroupZ", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_VI_NN)
void dump_text_vkCreateViSurfaceNN(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkViSurfaceCreateInfoNN>(pCreateInfo, settings, "const VkViSurfaceCreateInfoNN*", "pCreateInfo", 1, dump_text_VkViSurfaceCreateInfoNN);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_VI_NN
void dump_text_vkTrimCommandPoolKHR(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCommandPool>(commandPool, settings, "VkCommandPool", "commandPool", 1, dump_text_VkCommandPool); // MET
        dump_text_value<const VkCommandPoolTrimFlags>(flags, settings, "VkCommandPoolTrimFlags", "flags", 1, dump_text_VkCommandPoolTrimFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const uint32_t>(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDeviceGroupProperties>(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "VkPhysicalDeviceGroupProperties", "pPhysicalDeviceGroupProperties", 1, dump_text_VkPhysicalDeviceGroupProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalBufferInfo>(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", 1, dump_text_VkPhysicalDeviceExternalBufferInfo);
        dump_text_pointer<const VkExternalBufferProperties>(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", 1, dump_text_VkExternalBufferProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetMemoryWin32HandleKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetWin32HandleInfoKHR>(pGetWin32HandleInfo, settings, "const VkMemoryGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", 1, dump_text_VkMemoryGetWin32HandleInfoKHR);
        dump_text_pointer<const HANDLE>(pHandle, settings, "HANDLE*", "pHandle", 1, dump_text_HANDLE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagBits); // MET
        dump_text_value<const HANDLE>(handle, settings, "HANDLE", "handle", 1, dump_text_HANDLE); // MET
        dump_text_pointer<const VkMemoryWin32HandlePropertiesKHR>(pMemoryWin32HandleProperties, settings, "VkMemoryWin32HandlePropertiesKHR*", "pMemoryWin32HandleProperties", 1, dump_text_VkMemoryWin32HandlePropertiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkGetMemoryFdKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetFdInfoKHR>(pGetFdInfo, settings, "const VkMemoryGetFdInfoKHR*", "pGetFdInfo", 1, dump_text_VkMemoryGetFdInfoKHR);
        dump_text_pointer<const int>(pFd, settings, "int*", "pFd", 1, dump_text_int);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetMemoryFdPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagBits); // MET
        dump_text_value<const int>(fd, settings, "int", "fd", 1, dump_text_int); // MET
        dump_text_pointer<const VkMemoryFdPropertiesKHR>(pMemoryFdProperties, settings, "VkMemoryFdPropertiesKHR*", "pMemoryFdProperties", 1, dump_text_VkMemoryFdPropertiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalSemaphoreInfo>(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", 1, dump_text_VkPhysicalDeviceExternalSemaphoreInfo);
        dump_text_pointer<const VkExternalSemaphoreProperties>(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", 1, dump_text_VkExternalSemaphoreProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImportSemaphoreWin32HandleInfoKHR>(pImportSemaphoreWin32HandleInfo, settings, "const VkImportSemaphoreWin32HandleInfoKHR*", "pImportSemaphoreWin32HandleInfo", 1, dump_text_VkImportSemaphoreWin32HandleInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreGetWin32HandleInfoKHR>(pGetWin32HandleInfo, settings, "const VkSemaphoreGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", 1, dump_text_VkSemaphoreGetWin32HandleInfoKHR);
        dump_text_pointer<const HANDLE>(pHandle, settings, "HANDLE*", "pHandle", 1, dump_text_HANDLE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkImportSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImportSemaphoreFdInfoKHR>(pImportSemaphoreFdInfo, settings, "const VkImportSemaphoreFdInfoKHR*", "pImportSemaphoreFdInfo", 1, dump_text_VkImportSemaphoreFdInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreGetFdInfoKHR>(pGetFdInfo, settings, "const VkSemaphoreGetFdInfoKHR*", "pGetFdInfo", 1, dump_text_VkSemaphoreGetFdInfoKHR);
        dump_text_pointer<const int>(pFd, settings, "int*", "pFd", 1, dump_text_int);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSetKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(set, settings, "uint32_t", "set", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkWriteDescriptorSet>(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "const VkWriteDescriptorSet", "pDescriptorWrites", 1, dump_text_VkWriteDescriptorSet); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(set, settings, "uint32_t", "set", 1, dump_text_uint32_t); // MET
        dump_text_value<const void*>(pData, settings, "const void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkConditionalRenderingBeginInfoEXT>(pConditionalRenderingBegin, settings, "const VkConditionalRenderingBeginInfoEXT*", "pConditionalRenderingBegin", 1, dump_text_VkConditionalRenderingBeginInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorUpdateTemplateCreateInfo>(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorUpdateTemplateCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDescriptorUpdateTemplate>(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSet>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", 1, dump_text_VkDescriptorSet); // MET
        dump_text_value<const VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", 1, dump_text_VkDescriptorUpdateTemplate); // MET
        dump_text_value<const void*>(pData, settings, "const void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportWScalingNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkViewportWScalingNV>(pViewportWScalings, viewportCount, settings, "const VkViewportWScalingNV*", "const VkViewportWScalingNV", "pViewportWScalings", 1, dump_text_VkViewportWScalingNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkReleaseDisplayEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayKHR display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
void dump_text_vkAcquireXlibDisplayEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const Display*>(dpy, settings, "Display*", "dpy", 1, dump_text_Display); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
void dump_text_vkGetRandROutputDisplayEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const Display*>(dpy, settings, "Display*", "dpy", 1, dump_text_Display); // MET
        dump_text_value<const RROutput>(rrOutput, settings, "RROutput", "rrOutput", 1, dump_text_RROutput); // MET
        dump_text_pointer<const VkDisplayKHR>(pDisplay, settings, "VkDisplayKHR*", "pDisplay", 1, dump_text_VkDisplayKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
void dump_text_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSurfaceKHR>(surface, settings, "VkSurfaceKHR", "surface", 1, dump_text_VkSurfaceKHR); // MET
        dump_text_pointer<const VkSurfaceCapabilities2EXT>(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2EXT*", "pSurfaceCapabilities", 1, dump_text_VkSurfaceCapabilities2EXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDisplayPowerControlEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
        dump_text_pointer<const VkDisplayPowerInfoEXT>(pDisplayPowerInfo, settings, "const VkDisplayPowerInfoEXT*", "pDisplayPowerInfo", 1, dump_text_VkDisplayPowerInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkRegisterDeviceEventEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceEventInfoEXT>(pDeviceEventInfo, settings, "const VkDeviceEventInfoEXT*", "pDeviceEventInfo", 1, dump_text_VkDeviceEventInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkFence>(pFence, settings, "VkFence*", "pFence", 1, dump_text_VkFence);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkRegisterDisplayEventEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
        dump_text_pointer<const VkDisplayEventInfoEXT>(pDisplayEventInfo, settings, "const VkDisplayEventInfoEXT*", "pDisplayEventInfo", 1, dump_text_VkDisplayEventInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkFence>(pFence, settings, "VkFence*", "pFence", 1, dump_text_VkFence);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSwapchainCounterEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_value<const VkSurfaceCounterFlagBitsEXT>(counter, settings, "VkSurfaceCounterFlagBitsEXT", "counter", 1, dump_text_VkSurfaceCounterFlagBitsEXT); // MET
        dump_text_pointer<const uint64_t>(pCounterValue, settings, "uint64_t*", "pCounterValue", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkRefreshCycleDurationGOOGLE>(pDisplayTimingProperties, settings, "VkRefreshCycleDurationGOOGLE*", "pDisplayTimingProperties", 1, dump_text_VkRefreshCycleDurationGOOGLE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const uint32_t>(pPresentationTimingCount, settings, "uint32_t*", "pPresentationTimingCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPastPresentationTimingGOOGLE>(pPresentationTimings, *pPresentationTimingCount, settings, "VkPastPresentationTimingGOOGLE*", "VkPastPresentationTimingGOOGLE", "pPresentationTimings", 1, dump_text_VkPastPresentationTimingGOOGLE); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDiscardRectangleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstDiscardRectangle, settings, "uint32_t", "firstDiscardRectangle", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(discardRectangleCount, settings, "uint32_t", "discardRectangleCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRect2D>(pDiscardRectangles, discardRectangleCount, settings, "const VkRect2D*", "const VkRect2D", "pDiscardRectangles", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(discardRectangleEnable, settings, "VkBool32", "discardRectangleEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDiscardRectangleModeEXT>(discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", 1, dump_text_VkDiscardRectangleModeEXT); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetHdrMetadataEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(swapchainCount, settings, "uint32_t", "swapchainCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkSwapchainKHR>(pSwapchains, swapchainCount, settings, "const VkSwapchainKHR*", "const VkSwapchainKHR", "pSwapchains", 1, dump_text_VkSwapchainKHR); // HQA
        dump_text_array<const VkHdrMetadataEXT>(pMetadata, swapchainCount, settings, "const VkHdrMetadataEXT*", "const VkHdrMetadataEXT", "pMetadata", 1, dump_text_VkHdrMetadataEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateRenderPass2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderPassCreateInfo2>(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", 1, dump_text_VkRenderPassCreateInfo2);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkRenderPass>(pRenderPass, settings, "VkRenderPass*", "pRenderPass", 1, dump_text_VkRenderPass);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo*      pRenderPassBegin, const VkSubpassBeginInfo*      pSubpassBeginInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderPassBeginInfo>(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", 1, dump_text_VkRenderPassBeginInfo);
        dump_text_pointer<const VkSubpassBeginInfo>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", 1, dump_text_VkSubpassBeginInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdNextSubpass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo*      pSubpassBeginInfo, const VkSubpassEndInfo*        pSubpassEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSubpassBeginInfo>(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", 1, dump_text_VkSubpassBeginInfo);
        dump_text_pointer<const VkSubpassEndInfo>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", 1, dump_text_VkSubpassEndInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo*        pSubpassEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSubpassEndInfo>(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", 1, dump_text_VkSubpassEndInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSwapchainStatusKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceExternalFenceInfo>(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", 1, dump_text_VkPhysicalDeviceExternalFenceInfo);
        dump_text_pointer<const VkExternalFenceProperties>(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", 1, dump_text_VkExternalFenceProperties);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkImportFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImportFenceWin32HandleInfoKHR>(pImportFenceWin32HandleInfo, settings, "const VkImportFenceWin32HandleInfoKHR*", "pImportFenceWin32HandleInfo", 1, dump_text_VkImportFenceWin32HandleInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkFenceGetWin32HandleInfoKHR>(pGetWin32HandleInfo, settings, "const VkFenceGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", 1, dump_text_VkFenceGetWin32HandleInfoKHR);
        dump_text_pointer<const HANDLE>(pHandle, settings, "HANDLE*", "pHandle", 1, dump_text_HANDLE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkImportFenceFdKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImportFenceFdInfoKHR>(pImportFenceFdInfo, settings, "const VkImportFenceFdInfoKHR*", "pImportFenceFdInfo", 1, dump_text_VkImportFenceFdInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetFenceFdKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkFenceGetFdInfoKHR>(pGetFdInfo, settings, "const VkFenceGetFdInfoKHR*", "pGetFdInfo", 1, dump_text_VkFenceGetFdInfoKHR);
        dump_text_pointer<const int>(pFd, settings, "int*", "pFd", 1, dump_text_int);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const uint32_t>(pCounterCount, settings, "uint32_t*", "pCounterCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPerformanceCounterKHR>(pCounters, *pCounterCount, settings, "VkPerformanceCounterKHR*", "VkPerformanceCounterKHR", "pCounters", 1, dump_text_VkPerformanceCounterKHR); // HQA
        dump_text_array<const VkPerformanceCounterDescriptionKHR>(pCounterDescriptions, *pCounterCount, settings, "VkPerformanceCounterDescriptionKHR*", "VkPerformanceCounterDescriptionKHR", "pCounterDescriptions", 1, dump_text_VkPerformanceCounterDescriptionKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkQueryPoolPerformanceCreateInfoKHR>(pPerformanceQueryCreateInfo, settings, "const VkQueryPoolPerformanceCreateInfoKHR*", "pPerformanceQueryCreateInfo", 1, dump_text_VkQueryPoolPerformanceCreateInfoKHR);
        dump_text_pointer<const uint32_t>(pNumPasses, settings, "uint32_t*", "pNumPasses", 1, dump_text_uint32_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAcquireProfilingLockKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAcquireProfilingLockInfoKHR>(pInfo, settings, "const VkAcquireProfilingLockInfoKHR*", "pInfo", 1, dump_text_VkAcquireProfilingLockInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkReleaseProfilingLockKHR(ApiDumpInstance& dump_inst, VkDevice device)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSurfaceInfo2KHR>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", 1, dump_text_VkPhysicalDeviceSurfaceInfo2KHR);
        dump_text_pointer<const VkSurfaceCapabilities2KHR>(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2KHR*", "pSurfaceCapabilities", 1, dump_text_VkSurfaceCapabilities2KHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSurfaceInfo2KHR>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", 1, dump_text_VkPhysicalDeviceSurfaceInfo2KHR);
        dump_text_pointer<const uint32_t>(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSurfaceFormat2KHR>(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormat2KHR*", "VkSurfaceFormat2KHR", "pSurfaceFormats", 1, dump_text_VkSurfaceFormat2KHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayProperties2KHR>(pProperties, *pPropertyCount, settings, "VkDisplayProperties2KHR*", "VkDisplayProperties2KHR", "pProperties", 1, dump_text_VkDisplayProperties2KHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayPlaneProperties2KHR>(pProperties, *pPropertyCount, settings, "VkDisplayPlaneProperties2KHR*", "VkDisplayPlaneProperties2KHR", "pProperties", 1, dump_text_VkDisplayPlaneProperties2KHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDisplayModeProperties2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkDisplayModeProperties2KHR>(pProperties, *pPropertyCount, settings, "VkDisplayModeProperties2KHR*", "VkDisplayModeProperties2KHR", "pProperties", 1, dump_text_VkDisplayModeProperties2KHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkDisplayPlaneInfo2KHR>(pDisplayPlaneInfo, settings, "const VkDisplayPlaneInfo2KHR*", "pDisplayPlaneInfo", 1, dump_text_VkDisplayPlaneInfo2KHR);
        dump_text_pointer<const VkDisplayPlaneCapabilities2KHR>(pCapabilities, settings, "VkDisplayPlaneCapabilities2KHR*", "pCapabilities", 1, dump_text_VkDisplayPlaneCapabilities2KHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_IOS_MVK)
void dump_text_vkCreateIOSSurfaceMVK(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkIOSSurfaceCreateInfoMVK>(pCreateInfo, settings, "const VkIOSSurfaceCreateInfoMVK*", "pCreateInfo", 1, dump_text_VkIOSSurfaceCreateInfoMVK);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_IOS_MVK
#if defined(VK_USE_PLATFORM_MACOS_MVK)
void dump_text_vkCreateMacOSSurfaceMVK(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkMacOSSurfaceCreateInfoMVK>(pCreateInfo, settings, "const VkMacOSSurfaceCreateInfoMVK*", "pCreateInfo", 1, dump_text_VkMacOSSurfaceCreateInfoMVK);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_MACOS_MVK
void dump_text_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDebugUtilsObjectNameInfoEXT>(pNameInfo, settings, "const VkDebugUtilsObjectNameInfoEXT*", "pNameInfo", 1, dump_text_VkDebugUtilsObjectNameInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDebugUtilsObjectTagInfoEXT>(pTagInfo, settings, "const VkDebugUtilsObjectTagInfoEXT*", "pTagInfo", 1, dump_text_VkDebugUtilsObjectTagInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const VkDebugUtilsLabelEXT>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", 1, dump_text_VkDebugUtilsLabelEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const VkDebugUtilsLabelEXT>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", 1, dump_text_VkDebugUtilsLabelEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDebugUtilsLabelEXT>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", 1, dump_text_VkDebugUtilsLabelEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDebugUtilsLabelEXT>(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", 1, dump_text_VkDebugUtilsLabelEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkDebugUtilsMessengerCreateInfoEXT>(pCreateInfo, settings, "const VkDebugUtilsMessengerCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkDebugUtilsMessengerCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDebugUtilsMessengerEXT>(pMessenger, settings, "VkDebugUtilsMessengerEXT*", "pMessenger", 1, dump_text_VkDebugUtilsMessengerEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_value<const VkDebugUtilsMessengerEXT>(messenger, settings, "VkDebugUtilsMessengerEXT", "messenger", 1, dump_text_VkDebugUtilsMessengerEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_value<const VkDebugUtilsMessageSeverityFlagBitsEXT>(messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagBitsEXT", "messageSeverity", 1, dump_text_VkDebugUtilsMessageSeverityFlagBitsEXT); // MET
        dump_text_value<const VkDebugUtilsMessageTypeFlagsEXT>(messageTypes, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageTypes", 1, dump_text_VkDebugUtilsMessageTypeFlagsEXT); // MET
        dump_text_pointer<const VkDebugUtilsMessengerCallbackDataEXT>(pCallbackData, settings, "const VkDebugUtilsMessengerCallbackDataEXT*", "pCallbackData", 1, dump_text_VkDebugUtilsMessengerCallbackDataEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const AHardwareBuffer*>(buffer, settings, "const struct AHardwareBuffer*", "buffer", 1, dump_text_AHardwareBuffer); // MET
        dump_text_pointer<const VkAndroidHardwareBufferPropertiesANDROID>(pProperties, settings, "VkAndroidHardwareBufferPropertiesANDROID*", "pProperties", 1, dump_text_VkAndroidHardwareBufferPropertiesANDROID);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
void dump_text_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetAndroidHardwareBufferInfoANDROID>(pInfo, settings, "const VkMemoryGetAndroidHardwareBufferInfoANDROID*", "pInfo", 1, dump_text_VkMemoryGetAndroidHardwareBufferInfoANDROID);
        dump_text_pointer<const AHardwareBuffer*>(pBuffer, settings, "struct AHardwareBuffer**", "pBuffer", 1, dump_text_AHardwareBuffer);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_ANDROID_KHR
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                        device, VkPipelineCache                 pipelineCache, uint32_t                                        createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks*    pAllocator, VkPipeline*               pPipelines)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkExecutionGraphPipelineCreateInfoAMDX>(pCreateInfos, createInfoCount, settings, "const VkExecutionGraphPipelineCreateInfoAMDX*", "const VkExecutionGraphPipelineCreateInfoAMDX", "pCreateInfos", 1, dump_text_VkExecutionGraphPipelineCreateInfoAMDX); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkPipeline>(pPipelines, createInfoCount, settings, "VkPipeline*", "VkPipeline", "pPipelines", 1, dump_text_VkPipeline); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                        device, VkPipeline                                      executionGraph, VkExecutionGraphPipelineScratchSizeAMDX*        pSizeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(executionGraph, settings, "VkPipeline", "executionGraph", 1, dump_text_VkPipeline); // MET
        dump_text_pointer<const VkExecutionGraphPipelineScratchSizeAMDX>(pSizeInfo, settings, "VkExecutionGraphPipelineScratchSizeAMDX*", "pSizeInfo", 1, dump_text_VkExecutionGraphPipelineScratchSizeAMDX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                        device, VkPipeline                                      executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX*  pNodeInfo, uint32_t*                                       pNodeIndex)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(executionGraph, settings, "VkPipeline", "executionGraph", 1, dump_text_VkPipeline); // MET
        dump_text_pointer<const VkPipelineShaderStageNodeCreateInfoAMDX>(pNodeInfo, settings, "const VkPipelineShaderStageNodeCreateInfoAMDX*", "pNodeInfo", 1, dump_text_VkPipelineShaderStageNodeCreateInfoAMDX);
        dump_text_pointer<const uint32_t>(pNodeIndex, settings, "uint32_t*", "pNodeIndex", 1, dump_text_uint32_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer                                 commandBuffer, VkPipeline                                      executionGraph, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipeline>(executionGraph, settings, "VkPipeline", "executionGraph", 1, dump_text_VkPipeline); // MET
        dump_text_value<const VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCmdDispatchGraphAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", 1, dump_text_VkDeviceSize); // MET
        dump_text_pointer<const VkDispatchGraphCountInfoAMDX>(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", 1, dump_text_VkDispatchGraphCountInfoAMDX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", 1, dump_text_VkDeviceSize); // MET
        dump_text_pointer<const VkDispatchGraphCountInfoAMDX>(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", 1, dump_text_VkDispatchGraphCountInfoAMDX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, VkDeviceAddress                                 countInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(scratch, settings, "VkDeviceAddress", "scratch", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const VkDeviceSize>(scratchSize, settings, "VkDeviceSize", "scratchSize", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceAddress>(countInfo, settings, "VkDeviceAddress", "countInfo", 1, dump_text_VkDeviceAddress); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_vkCmdSetSampleLocationsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSampleLocationsInfoEXT>(pSampleLocationsInfo, settings, "const VkSampleLocationsInfoEXT*", "pSampleLocationsInfo", 1, dump_text_VkSampleLocationsInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkSampleCountFlagBits>(samples, settings, "VkSampleCountFlagBits", "samples", 1, dump_text_VkSampleCountFlagBits); // MET
        dump_text_pointer<const VkMultisamplePropertiesEXT>(pMultisampleProperties, settings, "VkMultisamplePropertiesEXT*", "pMultisampleProperties", 1, dump_text_VkMultisamplePropertiesEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageMemoryRequirementsInfo2>(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkImageMemoryRequirementsInfo2);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferMemoryRequirementsInfo2>(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkBufferMemoryRequirementsInfo2);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageSparseMemoryRequirementsInfo2>(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", 1, dump_text_VkImageSparseMemoryRequirementsInfo2);
        dump_text_pointer<const uint32_t>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageMemoryRequirements2>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "VkSparseImageMemoryRequirements2", "pSparseMemoryRequirements", 1, dump_text_VkSparseImageMemoryRequirements2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                           device, const VkAccelerationStructureCreateInfoKHR*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkAccelerationStructureKHR*                        pAccelerationStructure)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureCreateInfoKHR>(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkAccelerationStructureCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkAccelerationStructureKHR>(pAccelerationStructure, settings, "VkAccelerationStructureKHR*", "pAccelerationStructure", 1, dump_text_VkAccelerationStructureKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkAccelerationStructureKHR>(accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", 1, dump_text_VkAccelerationStructureKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureBuildGeometryInfoKHR>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "const VkAccelerationStructureBuildGeometryInfoKHR", "pInfos", 1, dump_text_VkAccelerationStructureBuildGeometryInfoKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer                  commandBuffer, uint32_t                                           infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress*             pIndirectDeviceAddresses, const uint32_t*                    pIndirectStrides, const uint32_t* const*             ppMaxPrimitiveCounts)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureBuildGeometryInfoKHR>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "const VkAccelerationStructureBuildGeometryInfoKHR", "pInfos", 1, dump_text_VkAccelerationStructureBuildGeometryInfoKHR); // HQA
        dump_text_array<const VkDeviceAddress>(pIndirectDeviceAddresses, infoCount, settings, "const VkDeviceAddress*", "const VkDeviceAddress", "pIndirectDeviceAddresses", 1, dump_text_VkDeviceAddress); // HQA
        dump_text_array<const uint32_t>(pIndirectStrides, infoCount, settings, "const uint32_t*", "const uint32_t", "pIndirectStrides", 1, dump_text_uint32_t); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                           device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureBuildGeometryInfoKHR>(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "const VkAccelerationStructureBuildGeometryInfoKHR", "pInfos", 1, dump_text_VkAccelerationStructureBuildGeometryInfoKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyAccelerationStructureInfoKHR>(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", 1, dump_text_VkCopyAccelerationStructureInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyAccelerationStructureToMemoryInfoKHR>(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", 1, dump_text_VkCopyAccelerationStructureToMemoryInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyMemoryToAccelerationStructureInfoKHR>(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", 1, dump_text_VkCopyMemoryToAccelerationStructureInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType  queryType, size_t       dataSize, void* pData, size_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureKHR>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "const VkAccelerationStructureKHR", "pAccelerationStructures", 1, dump_text_VkAccelerationStructureKHR); // HQA
        dump_text_value<const VkQueryType>(queryType, settings, "VkQueryType", "queryType", 1, dump_text_VkQueryType); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
        dump_text_value<const size_t>(stride, settings, "size_t", "stride", 1, dump_text_size_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyAccelerationStructureInfoKHR>(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", 1, dump_text_VkCopyAccelerationStructureInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyAccelerationStructureToMemoryInfoKHR>(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", 1, dump_text_VkCopyAccelerationStructureToMemoryInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyMemoryToAccelerationStructureInfoKHR>(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", 1, dump_text_VkCopyMemoryToAccelerationStructureInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDeviceAddress result, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceAddress(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureDeviceAddressInfoKHR>(pInfo, settings, "const VkAccelerationStructureDeviceAddressInfoKHR*", "pInfo", 1, dump_text_VkAccelerationStructureDeviceAddressInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureKHR>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "const VkAccelerationStructureKHR", "pAccelerationStructures", 1, dump_text_VkAccelerationStructureKHR); // HQA
        dump_text_value<const VkQueryType>(queryType, settings, "VkQueryType", "queryType", 1, dump_text_VkQueryType); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureVersionInfoKHR>(pVersionInfo, settings, "const VkAccelerationStructureVersionInfoKHR*", "pVersionInfo", 1, dump_text_VkAccelerationStructureVersionInfoKHR);
        dump_text_pointer<const VkAccelerationStructureCompatibilityKHR>(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", 1, dump_text_VkAccelerationStructureCompatibilityKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance& dump_inst, VkDevice                                            device, VkAccelerationStructureBuildTypeKHR                 buildType, const VkAccelerationStructureBuildGeometryInfoKHR*  pBuildInfo, const uint32_t*  pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR*           pSizeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkAccelerationStructureBuildTypeKHR>(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", 1, dump_text_VkAccelerationStructureBuildTypeKHR); // MET
        dump_text_pointer<const VkAccelerationStructureBuildGeometryInfoKHR>(pBuildInfo, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pBuildInfo", 1, dump_text_VkAccelerationStructureBuildGeometryInfoKHR);
        dump_text_array<const uint32_t>(pMaxPrimitiveCounts, pBuildInfo->geometryCount, settings, "const uint32_t*", "const uint32_t", "pMaxPrimitiveCounts", 1, dump_text_uint32_t); // HQA
        dump_text_pointer<const VkAccelerationStructureBuildSizesInfoKHR>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", 1, dump_text_VkAccelerationStructureBuildSizesInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSamplerYcbcrConversionCreateInfo>(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", 1, dump_text_VkSamplerYcbcrConversionCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSamplerYcbcrConversion>(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", 1, dump_text_VkSamplerYcbcrConversion);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSamplerYcbcrConversion>(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", 1, dump_text_VkSamplerYcbcrConversion); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindBufferMemory2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindBufferMemoryInfo>(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "const VkBindBufferMemoryInfo", "pBindInfos", 1, dump_text_VkBindBufferMemoryInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindImageMemory2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindImageMemoryInfo>(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "const VkBindImageMemoryInfo", "pBindInfos", 1, dump_text_VkBindImageMemoryInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkImageDrmFormatModifierPropertiesEXT>(pProperties, settings, "VkImageDrmFormatModifierPropertiesEXT*", "pProperties", 1, dump_text_VkImageDrmFormatModifierPropertiesEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateValidationCacheEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkValidationCacheCreateInfoEXT>(pCreateInfo, settings, "const VkValidationCacheCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkValidationCacheCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkValidationCacheEXT>(pValidationCache, settings, "VkValidationCacheEXT*", "pValidationCache", 1, dump_text_VkValidationCacheEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyValidationCacheEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkValidationCacheEXT>(validationCache, settings, "VkValidationCacheEXT", "validationCache", 1, dump_text_VkValidationCacheEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkMergeValidationCachesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkValidationCacheEXT>(dstCache, settings, "VkValidationCacheEXT", "dstCache", 1, dump_text_VkValidationCacheEXT); // MET
        dump_text_value<const uint32_t>(srcCacheCount, settings, "uint32_t", "srcCacheCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkValidationCacheEXT>(pSrcCaches, srcCacheCount, settings, "const VkValidationCacheEXT*", "const VkValidationCacheEXT", "pSrcCaches", 1, dump_text_VkValidationCacheEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetValidationCacheDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkValidationCacheEXT>(validationCache, settings, "VkValidationCacheEXT", "validationCache", 1, dump_text_VkValidationCacheEXT); // MET
        dump_text_pointer<const size_t>(pDataSize, settings, "size_t*", "pDataSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindShadingRateImageNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImageView>(imageView, settings, "VkImageView", "imageView", 1, dump_text_VkImageView); // MET
        dump_text_value<const VkImageLayout>(imageLayout, settings, "VkImageLayout", "imageLayout", 1, dump_text_VkImageLayout); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkShadingRatePaletteNV>(pShadingRatePalettes, viewportCount, settings, "const VkShadingRatePaletteNV*", "const VkShadingRatePaletteNV", "pShadingRatePalettes", 1, dump_text_VkShadingRatePaletteNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCoarseSampleOrderTypeNV>(sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", 1, dump_text_VkCoarseSampleOrderTypeNV); // MET
        dump_text_value<const uint32_t>(customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCoarseSampleOrderCustomNV>(pCustomSampleOrders, customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "const VkCoarseSampleOrderCustomNV", "pCustomSampleOrders", 1, dump_text_VkCoarseSampleOrderCustomNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateAccelerationStructureNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureCreateInfoNV>(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoNV*", "pCreateInfo", 1, dump_text_VkAccelerationStructureCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkAccelerationStructureNV>(pAccelerationStructure, settings, "VkAccelerationStructureNV*", "pAccelerationStructure", 1, dump_text_VkAccelerationStructureNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkAccelerationStructureNV>(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureMemoryRequirementsInfoNV>(pInfo, settings, "const VkAccelerationStructureMemoryRequirementsInfoNV*", "pInfo", 1, dump_text_VkAccelerationStructureMemoryRequirementsInfoNV);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2KHR*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindAccelerationStructureMemoryNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(bindInfoCount, settings, "uint32_t", "bindInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBindAccelerationStructureMemoryInfoNV>(pBindInfos, bindInfoCount, settings, "const VkBindAccelerationStructureMemoryInfoNV*", "const VkBindAccelerationStructureMemoryInfoNV", "pBindInfos", 1, dump_text_VkBindAccelerationStructureMemoryInfoNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkAccelerationStructureInfoNV>(pInfo, settings, "const VkAccelerationStructureInfoNV*", "pInfo", 1, dump_text_VkAccelerationStructureInfoNV);
        dump_text_value<const VkBuffer>(instanceData, settings, "VkBuffer", "instanceData", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(instanceOffset, settings, "VkDeviceSize", "instanceOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBool32>(update, settings, "VkBool32", "update", 1, dump_text_VkBool32); // MET
        dump_text_value<const VkAccelerationStructureNV>(dst, settings, "VkAccelerationStructureNV", "dst", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_value<const VkAccelerationStructureNV>(src, settings, "VkAccelerationStructureNV", "src", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_value<const VkBuffer>(scratch, settings, "VkBuffer", "scratch", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(scratchOffset, settings, "VkDeviceSize", "scratchOffset", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkAccelerationStructureNV>(dst, settings, "VkAccelerationStructureNV", "dst", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_value<const VkAccelerationStructureNV>(src, settings, "VkAccelerationStructureNV", "src", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_value<const VkCopyAccelerationStructureModeKHR>(mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", 1, dump_text_VkCopyAccelerationStructureModeKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdTraceRaysNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(raygenShaderBindingTableBuffer, settings, "VkBuffer", "raygenShaderBindingTableBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(raygenShaderBindingOffset, settings, "VkDeviceSize", "raygenShaderBindingOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(missShaderBindingTableBuffer, settings, "VkBuffer", "missShaderBindingTableBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(missShaderBindingOffset, settings, "VkDeviceSize", "missShaderBindingOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(missShaderBindingStride, settings, "VkDeviceSize", "missShaderBindingStride", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(hitShaderBindingTableBuffer, settings, "VkBuffer", "hitShaderBindingTableBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(hitShaderBindingOffset, settings, "VkDeviceSize", "hitShaderBindingOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(hitShaderBindingStride, settings, "VkDeviceSize", "hitShaderBindingStride", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(callableShaderBindingTableBuffer, settings, "VkBuffer", "callableShaderBindingTableBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(callableShaderBindingOffset, settings, "VkDeviceSize", "callableShaderBindingOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(callableShaderBindingStride, settings, "VkDeviceSize", "callableShaderBindingStride", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(width, settings, "uint32_t", "width", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(height, settings, "uint32_t", "height", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(depth, settings, "uint32_t", "depth", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateRayTracingPipelinesNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRayTracingPipelineCreateInfoNV>(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoNV*", "const VkRayTracingPipelineCreateInfoNV", "pCreateInfos", 1, dump_text_VkRayTracingPipelineCreateInfoNV); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkPipeline>(pPipelines, createInfoCount, settings, "VkPipeline*", "VkPipeline", "pPipelines", 1, dump_text_VkPipeline); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCount, settings, "uint32_t", "groupCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCount, settings, "uint32_t", "groupCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetAccelerationStructureHandleNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkAccelerationStructureNV>(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", 1, dump_text_VkAccelerationStructureNV); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkAccelerationStructureNV>(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "const VkAccelerationStructureNV", "pAccelerationStructures", 1, dump_text_VkAccelerationStructureNV); // HQA
        dump_text_value<const VkQueryType>(queryType, settings, "VkQueryType", "queryType", 1, dump_text_VkQueryType); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCompileDeferredNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipeline pipeline, uint32_t shader)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(shader, settings, "uint32_t", "shader", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorSetLayoutCreateInfo>(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", 1, dump_text_VkDescriptorSetLayoutCreateInfo);
        dump_text_pointer<const VkDescriptorSetLayoutSupport>(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", 1, dump_text_VkDescriptorSetLayoutSupport);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagBits); // MET
        dump_text_value<const void*>(pHostPointer, settings, "const void*", "pHostPointer", 1, dump_text_void); // MET
        dump_text_pointer<const VkMemoryHostPointerPropertiesEXT>(pMemoryHostPointerProperties, settings, "VkMemoryHostPointerPropertiesEXT*", "pMemoryHostPointerProperties", 1, dump_text_VkMemoryHostPointerPropertiesEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteBufferMarkerAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlagBits>(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", 1, dump_text_VkPipelineStageFlagBits); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(marker, settings, "uint32_t", "marker", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteBufferMarker2AMD(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2               stage, VkBuffer                                            dstBuffer, VkDeviceSize                                        dstOffset, uint32_t                                            marker)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlags2>(stage, settings, "VkPipelineStageFlags2", "stage", 1, dump_text_VkPipelineStageFlags2); // MET
        dump_text_value<const VkBuffer>(dstBuffer, settings, "VkBuffer", "dstBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(dstOffset, settings, "VkDeviceSize", "dstOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(marker, settings, "uint32_t", "marker", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", 1, dump_text_uint32_t);
        dump_text_array<const VkTimeDomainKHR>(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "VkTimeDomainKHR", "pTimeDomains", 1, dump_text_VkTimeDomainKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", 1, dump_text_uint32_t);
        dump_text_array<const VkTimeDomainKHR>(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "VkTimeDomainKHR", "pTimeDomains", 1, dump_text_VkTimeDomainKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetCalibratedTimestampsKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(timestampCount, settings, "uint32_t", "timestampCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCalibratedTimestampInfoKHR>(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "const VkCalibratedTimestampInfoKHR", "pTimestampInfos", 1, dump_text_VkCalibratedTimestampInfoKHR); // HQA
        dump_text_array<const uint64_t>(pTimestamps, timestampCount, settings, "uint64_t*", "uint64_t", "pTimestamps", 1, dump_text_uint64_t); // HQA
        dump_text_pointer<const uint64_t>(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetCalibratedTimestampsEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(timestampCount, settings, "uint32_t", "timestampCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkCalibratedTimestampInfoKHR>(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "const VkCalibratedTimestampInfoKHR", "pTimestampInfos", 1, dump_text_VkCalibratedTimestampInfoKHR); // HQA
        dump_text_array<const uint64_t>(pTimestamps, timestampCount, settings, "uint64_t*", "uint64_t", "pTimestamps", 1, dump_text_uint64_t); // HQA
        dump_text_pointer<const uint64_t>(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(taskCount, settings, "uint32_t", "taskCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstTask, settings, "uint32_t", "firstTask", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBool32>(pExclusiveScissorEnables, exclusiveScissorCount, settings, "const VkBool32*", "const VkBool32", "pExclusiveScissorEnables", 1, dump_text_VkBool32); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetExclusiveScissorNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRect2D>(pExclusiveScissors, exclusiveScissorCount, settings, "const VkRect2D*", "const VkRect2D", "pExclusiveScissors", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCheckpointNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const void*>(pCheckpointMarker, settings, "const void*", "pCheckpointMarker", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetQueueCheckpointDataNV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const uint32_t>(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCheckpointDataNV>(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointDataNV*", "VkCheckpointDataNV", "pCheckpointData", 1, dump_text_VkCheckpointDataNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetQueueCheckpointData2NV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const uint32_t>(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCheckpointData2NV>(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointData2NV*", "VkCheckpointData2NV", "pCheckpointData", 1, dump_text_VkCheckpointData2NV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSemaphoreCounterValueKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSemaphore>(semaphore, settings, "VkSemaphore", "semaphore", 1, dump_text_VkSemaphore); // MET
        dump_text_pointer<const uint64_t>(pValue, settings, "uint64_t*", "pValue", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWaitSemaphoresKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreWaitInfo>(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", 1, dump_text_VkSemaphoreWaitInfo);
        dump_text_value<const uint64_t>(timeout, settings, "uint64_t", "timeout", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSignalSemaphoreKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreSignalInfo>(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", 1, dump_text_VkSemaphoreSignalInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkInitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkInitializePerformanceApiInfoINTEL>(pInitializeInfo, settings, "const VkInitializePerformanceApiInfoINTEL*", "pInitializeInfo", 1, dump_text_VkInitializePerformanceApiInfoINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUninitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkDevice device)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPerformanceMarkerInfoINTEL>(pMarkerInfo, settings, "const VkPerformanceMarkerInfoINTEL*", "pMarkerInfo", 1, dump_text_VkPerformanceMarkerInfoINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPerformanceStreamMarkerInfoINTEL>(pMarkerInfo, settings, "const VkPerformanceStreamMarkerInfoINTEL*", "pMarkerInfo", 1, dump_text_VkPerformanceStreamMarkerInfoINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance& dump_inst, VkResult result, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPerformanceOverrideInfoINTEL>(pOverrideInfo, settings, "const VkPerformanceOverrideInfoINTEL*", "pOverrideInfo", 1, dump_text_VkPerformanceOverrideInfoINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPerformanceConfigurationAcquireInfoINTEL>(pAcquireInfo, settings, "const VkPerformanceConfigurationAcquireInfoINTEL*", "pAcquireInfo", 1, dump_text_VkPerformanceConfigurationAcquireInfoINTEL);
        dump_text_pointer<const VkPerformanceConfigurationINTEL>(pConfiguration, settings, "VkPerformanceConfigurationINTEL*", "pConfiguration", 1, dump_text_VkPerformanceConfigurationINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPerformanceConfigurationINTEL configuration)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPerformanceConfigurationINTEL>(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", 1, dump_text_VkPerformanceConfigurationINTEL); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkResult result, VkQueue queue, VkPerformanceConfigurationINTEL configuration)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_value<const VkPerformanceConfigurationINTEL>(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", 1, dump_text_VkPerformanceConfigurationINTEL); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPerformanceParameterINTEL(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPerformanceParameterTypeINTEL>(parameter, settings, "VkPerformanceParameterTypeINTEL", "parameter", 1, dump_text_VkPerformanceParameterTypeINTEL); // MET
        dump_text_pointer<const VkPerformanceValueINTEL>(pValue, settings, "VkPerformanceValueINTEL*", "pValue", 1, dump_text_VkPerformanceValueINTEL);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetLocalDimmingAMD(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapChain, settings, "VkSwapchainKHR", "swapChain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_value<const VkBool32>(localDimmingEnable, settings, "VkBool32", "localDimmingEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkImagePipeSurfaceCreateInfoFUCHSIA>(pCreateInfo, settings, "const VkImagePipeSurfaceCreateInfoFUCHSIA*", "pCreateInfo", 1, dump_text_VkImagePipeSurfaceCreateInfoFUCHSIA);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_vkCreateMetalSurfaceEXT(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkMetalSurfaceCreateInfoEXT>(pCreateInfo, settings, "const VkMetalSurfaceCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkMetalSurfaceCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pFragmentShadingRateCount, settings, "uint32_t*", "pFragmentShadingRateCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDeviceFragmentShadingRateKHR>(pFragmentShadingRates, *pFragmentShadingRateCount, settings, "VkPhysicalDeviceFragmentShadingRateKHR*", "VkPhysicalDeviceFragmentShadingRateKHR", "pFragmentShadingRates", 1, dump_text_VkPhysicalDeviceFragmentShadingRateKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer           commandBuffer, const VkExtent2D*                           pFragmentSize, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2])
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkExtent2D>(pFragmentSize, settings, "const VkExtent2D*", "pFragmentSize", 1, dump_text_VkExtent2D);
        dump_text_array<const VkFragmentShadingRateCombinerOpKHR>(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "const VkFragmentShadingRateCombinerOpKHR", "combinerOps", 1, dump_text_VkFragmentShadingRateCombinerOpKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingAttachmentLocationInfo>(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", 1, dump_text_VkRenderingAttachmentLocationInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingInputAttachmentIndexInfo>(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", 1, dump_text_VkRenderingInputAttachmentIndexInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferDeviceAddressEXT(ApiDumpInstance& dump_inst, VkDeviceAddress result, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceAddress(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferDeviceAddressInfo>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", 1, dump_text_VkBufferDeviceAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pToolCount, settings, "uint32_t*", "pToolCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPhysicalDeviceToolProperties>(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "VkPhysicalDeviceToolProperties", "pToolProperties", 1, dump_text_VkPhysicalDeviceToolProperties); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWaitForPresentKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_value<const uint64_t>(presentId, settings, "uint64_t", "presentId", 1, dump_text_uint64_t); // MET
        dump_text_value<const uint64_t>(timeout, settings, "uint64_t", "timeout", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCooperativeMatrixPropertiesNV>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesNV*", "VkCooperativeMatrixPropertiesNV", "pProperties", 1, dump_text_VkCooperativeMatrixPropertiesNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pCombinationCount, settings, "uint32_t*", "pCombinationCount", 1, dump_text_uint32_t);
        dump_text_array<const VkFramebufferMixedSamplesCombinationNV>(pCombinations, *pCombinationCount, settings, "VkFramebufferMixedSamplesCombinationNV*", "VkFramebufferMixedSamplesCombinationNV", "pCombinations", 1, dump_text_VkFramebufferMixedSamplesCombinationNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSurfaceInfo2KHR>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", 1, dump_text_VkPhysicalDeviceSurfaceInfo2KHR);
        dump_text_pointer<const uint32_t>(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPresentModeKHR>(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "VkPresentModeKHR", "pPresentModes", 1, dump_text_VkPresentModeKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceSurfaceInfo2KHR>(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", 1, dump_text_VkPhysicalDeviceSurfaceInfo2KHR);
        dump_text_pointer<const VkDeviceGroupPresentModeFlagsKHR>(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", 1, dump_text_VkDeviceGroupPresentModeFlagsKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
void dump_text_vkCreateHeadlessSurfaceEXT(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkHeadlessSurfaceCreateInfoEXT>(pCreateInfo, settings, "const VkHeadlessSurfaceCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkHeadlessSurfaceCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDeviceAddress result, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceAddress(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferDeviceAddressInfo>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", 1, dump_text_VkBufferDeviceAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, uint64_t result, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint64_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferDeviceAddressInfo>(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", 1, dump_text_VkBufferDeviceAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, uint64_t result, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint64_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceMemoryOpaqueCaptureAddressInfo>(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", 1, dump_text_VkDeviceMemoryOpaqueCaptureAddressInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLineStippleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", 1, dump_text_uint16_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkResetQueryPoolEXT(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(queryCount, settings, "uint32_t", "queryCount", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCullModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCullModeFlags>(cullMode, settings, "VkCullModeFlags", "cullMode", 1, dump_text_VkCullModeFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetFrontFaceEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkFrontFace>(frontFace, settings, "VkFrontFace", "frontFace", 1, dump_text_VkFrontFace); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPrimitiveTopology>(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", 1, dump_text_VkPrimitiveTopology); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkViewport>(pViewports, viewportCount, settings, "const VkViewport*", "const VkViewport", "pViewports", 1, dump_text_VkViewport); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetScissorWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(scissorCount, settings, "uint32_t", "scissorCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRect2D>(pScissors, scissorCount, settings, "const VkRect2D*", "const VkRect2D", "pScissors", 1, dump_text_VkRect2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindVertexBuffers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstBinding, settings, "uint32_t", "firstBinding", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(bindingCount, settings, "uint32_t", "bindingCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBuffer>(pBuffers, bindingCount, settings, "const VkBuffer*", "const VkBuffer", "pBuffers", 1, dump_text_VkBuffer); // HQA
        dump_text_array<const VkDeviceSize>(pOffsets, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", 1, dump_text_VkDeviceSize); // HQA
        dump_text_array<const VkDeviceSize>(pSizes, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pSizes", 1, dump_text_VkDeviceSize); // HQA
        dump_text_array<const VkDeviceSize>(pStrides, bindingCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pStrides", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthTestEnable, settings, "VkBool32", "depthTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthCompareOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCompareOp>(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", 1, dump_text_VkCompareOp); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetStencilOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkStencilFaceFlags>(faceMask, settings, "VkStencilFaceFlags", "faceMask", 1, dump_text_VkStencilFaceFlags); // MET
        dump_text_value<const VkStencilOp>(failOp, settings, "VkStencilOp", "failOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkStencilOp>(passOp, settings, "VkStencilOp", "passOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkStencilOp>(depthFailOp, settings, "VkStencilOp", "depthFailOp", 1, dump_text_VkStencilOp); // MET
        dump_text_value<const VkCompareOp>(compareOp, settings, "VkCompareOp", "compareOp", 1, dump_text_VkCompareOp); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateDeferredOperationKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkDeferredOperationKHR>(pDeferredOperation, settings, "VkDeferredOperationKHR*", "pDeferredOperation", 1, dump_text_VkDeferredOperationKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyDeferredOperationKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(operation, settings, "VkDeferredOperationKHR", "operation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance& dump_inst, uint32_t result, VkDevice device, VkDeferredOperationKHR operation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_uint32_t(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(operation, settings, "VkDeferredOperationKHR", "operation", 1, dump_text_VkDeferredOperationKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeferredOperationResultKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR operation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(operation, settings, "VkDeferredOperationKHR", "operation", 1, dump_text_VkDeferredOperationKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDeferredOperationJoinKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR operation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(operation, settings, "VkDeferredOperationKHR", "operation", 1, dump_text_VkDeferredOperationKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineInfoKHR>(pPipelineInfo, settings, "const VkPipelineInfoKHR*", "pPipelineInfo", 1, dump_text_VkPipelineInfoKHR);
        dump_text_pointer<const uint32_t>(pExecutableCount, settings, "uint32_t*", "pExecutableCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPipelineExecutablePropertiesKHR>(pProperties, *pExecutableCount, settings, "VkPipelineExecutablePropertiesKHR*", "VkPipelineExecutablePropertiesKHR", "pProperties", 1, dump_text_VkPipelineExecutablePropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineExecutableInfoKHR>(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", 1, dump_text_VkPipelineExecutableInfoKHR);
        dump_text_pointer<const uint32_t>(pStatisticCount, settings, "uint32_t*", "pStatisticCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPipelineExecutableStatisticKHR>(pStatistics, *pStatisticCount, settings, "VkPipelineExecutableStatisticKHR*", "VkPipelineExecutableStatisticKHR", "pStatistics", 1, dump_text_VkPipelineExecutableStatisticKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineExecutableInfoKHR>(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", 1, dump_text_VkPipelineExecutableInfoKHR);
        dump_text_pointer<const uint32_t>(pInternalRepresentationCount, settings, "uint32_t*", "pInternalRepresentationCount", 1, dump_text_uint32_t);
        dump_text_array<const VkPipelineExecutableInternalRepresentationKHR>(pInternalRepresentations, *pInternalRepresentationCount, settings, "VkPipelineExecutableInternalRepresentationKHR*", "VkPipelineExecutableInternalRepresentationKHR", "pInternalRepresentations", 1, dump_text_VkPipelineExecutableInternalRepresentationKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMemoryToImageEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyMemoryToImageInfo*    pCopyMemoryToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyMemoryToImageInfo>(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", 1, dump_text_VkCopyMemoryToImageInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyImageToMemoryEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyImageToMemoryInfo*    pCopyImageToMemoryInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyImageToMemoryInfo>(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", 1, dump_text_VkCopyImageToMemoryInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyImageToImageEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCopyImageToImageInfo*    pCopyImageToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCopyImageToImageInfo>(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", 1, dump_text_VkCopyImageToImageInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkTransitionImageLayoutEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo*    pTransitions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(transitionCount, settings, "uint32_t", "transitionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkHostImageLayoutTransitionInfo>(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "const VkHostImageLayoutTransitionInfo", "pTransitions", 1, dump_text_VkHostImageLayoutTransitionInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSubresourceLayout2EXT(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkImageSubresource2>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", 1, dump_text_VkImageSubresource2);
        dump_text_pointer<const VkSubresourceLayout2>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", 1, dump_text_VkSubresourceLayout2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkMapMemory2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryMapInfo>(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", 1, dump_text_VkMemoryMapInfo);
        dump_text_pointer<const void*>(ppData, settings, "void**", "ppData", 1, dump_text_void);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUnmapMemory2KHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryUnmapInfo>(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", 1, dump_text_VkMemoryUnmapInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkReleaseSwapchainImagesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkReleaseSwapchainImagesInfoEXT>(pReleaseInfo, settings, "const VkReleaseSwapchainImagesInfoEXT*", "pReleaseInfo", 1, dump_text_VkReleaseSwapchainImagesInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkGeneratedCommandsMemoryRequirementsInfoNV>(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoNV*", "pInfo", 1, dump_text_VkGeneratedCommandsMemoryRequirementsInfoNV);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkGeneratedCommandsInfoNV>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", 1, dump_text_VkGeneratedCommandsInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(isPreprocessed, settings, "VkBool32", "isPreprocessed", 1, dump_text_VkBool32); // MET
        dump_text_pointer<const VkGeneratedCommandsInfoNV>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", 1, dump_text_VkGeneratedCommandsInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(groupIndex, settings, "uint32_t", "groupIndex", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkIndirectCommandsLayoutCreateInfoNV>(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoNV*", "pCreateInfo", 1, dump_text_VkIndirectCommandsLayoutCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkIndirectCommandsLayoutNV>(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV*", "pIndirectCommandsLayout", 1, dump_text_VkIndirectCommandsLayoutNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkIndirectCommandsLayoutNV>(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", 1, dump_text_VkIndirectCommandsLayoutNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBias2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT*         pDepthBiasInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDepthBiasInfoEXT>(pDepthBiasInfo, settings, "const VkDepthBiasInfoEXT*", "pDepthBiasInfo", 1, dump_text_VkDepthBiasInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAcquireDrmDisplayEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const int32_t>(drmFd, settings, "int32_t", "drmFd", 1, dump_text_int32_t); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDrmDisplayEXT(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const int32_t>(drmFd, settings, "int32_t", "drmFd", 1, dump_text_int32_t); // MET
        dump_text_value<const uint32_t>(connectorId, settings, "uint32_t", "connectorId", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkDisplayKHR>(display, settings, "VkDisplayKHR*", "display", 1, dump_text_VkDisplayKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreatePrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPrivateDataSlotCreateInfo>(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", 1, dump_text_VkPrivateDataSlotCreateInfo);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkPrivateDataSlot>(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", 1, dump_text_VkPrivateDataSlot);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetPrivateDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkObjectType>(objectType, settings, "VkObjectType", "objectType", 1, dump_text_VkObjectType); // MET
        dump_text_value<const uint64_t>(objectHandle, settings, "uint64_t", "objectHandle", 1, dump_text_uint64_t); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_value<const uint64_t>(data, settings, "uint64_t", "data", 1, dump_text_uint64_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPrivateDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkObjectType>(objectType, settings, "VkObjectType", "objectType", 1, dump_text_VkObjectType); // MET
        dump_text_value<const uint64_t>(objectHandle, settings, "uint64_t", "objectHandle", 1, dump_text_uint64_t); // MET
        dump_text_value<const VkPrivateDataSlot>(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", 1, dump_text_VkPrivateDataSlot); // MET
        dump_text_pointer<const uint64_t>(pData, settings, "uint64_t*", "pData", 1, dump_text_uint64_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR>(pQualityLevelInfo, settings, "const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*", "pQualityLevelInfo", 1, dump_text_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR);
        dump_text_pointer<const VkVideoEncodeQualityLevelPropertiesKHR>(pQualityLevelProperties, settings, "VkVideoEncodeQualityLevelPropertiesKHR*", "pQualityLevelProperties", 1, dump_text_VkVideoEncodeQualityLevelPropertiesKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkVideoEncodeSessionParametersGetInfoKHR>(pVideoSessionParametersInfo, settings, "const VkVideoEncodeSessionParametersGetInfoKHR*", "pVideoSessionParametersInfo", 1, dump_text_VkVideoEncodeSessionParametersGetInfoKHR);
        dump_text_pointer<const VkVideoEncodeSessionParametersFeedbackInfoKHR>(pFeedbackInfo, settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR*", "pFeedbackInfo", 1, dump_text_VkVideoEncodeSessionParametersFeedbackInfoKHR);
        dump_text_pointer<const size_t>(pDataSize, settings, "size_t*", "pDataSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEncodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkVideoEncodeInfoKHR>(pEncodeInfo, settings, "const VkVideoEncodeInfoKHR*", "pEncodeInfo", 1, dump_text_VkVideoEncodeInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCreateCudaModuleNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCudaModuleCreateInfoNV>(pCreateInfo, settings, "const VkCudaModuleCreateInfoNV*", "pCreateInfo", 1, dump_text_VkCudaModuleCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkCudaModuleNV>(pModule, settings, "VkCudaModuleNV*", "pModule", 1, dump_text_VkCudaModuleNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkGetCudaModuleCacheNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCudaModuleNV>(module, settings, "VkCudaModuleNV", "module", 1, dump_text_VkCudaModuleNV); // MET
        dump_text_pointer<const size_t>(pCacheSize, settings, "size_t*", "pCacheSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pCacheData, settings, "void*", "pCacheData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCreateCudaFunctionNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkCudaFunctionCreateInfoNV>(pCreateInfo, settings, "const VkCudaFunctionCreateInfoNV*", "pCreateInfo", 1, dump_text_VkCudaFunctionCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkCudaFunctionNV>(pFunction, settings, "VkCudaFunctionNV*", "pFunction", 1, dump_text_VkCudaFunctionNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkDestroyCudaModuleNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCudaModuleNV>(module, settings, "VkCudaModuleNV", "module", 1, dump_text_VkCudaModuleNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkDestroyCudaFunctionNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkCudaFunctionNV>(function, settings, "VkCudaFunctionNV", "function", 1, dump_text_VkCudaFunctionNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
#if defined(VK_ENABLE_BETA_EXTENSIONS)
void dump_text_vkCmdCudaLaunchKernelNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCudaLaunchInfoNV>(pLaunchInfo, settings, "const VkCudaLaunchInfoNV*", "pLaunchInfo", 1, dump_text_VkCudaLaunchInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_ENABLE_BETA_EXTENSIONS
void dump_text_vkCmdDispatchTileQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPerTileBeginInfoQCOM>(pPerTileBeginInfo, settings, "const VkPerTileBeginInfoQCOM*", "pPerTileBeginInfo", 1, dump_text_VkPerTileBeginInfoQCOM);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPerTileEndInfoQCOM>(pPerTileEndInfo, settings, "const VkPerTileEndInfoQCOM*", "pPerTileEndInfo", 1, dump_text_VkPerTileEndInfoQCOM);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_vkExportMetalObjectsEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkExportMetalObjectsInfoEXT>(pMetalObjectsInfo, settings, "VkExportMetalObjectsInfoEXT*", "pMetalObjectsInfo", 1, dump_text_VkExportMetalObjectsInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_vkCmdSetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkEvent                                             event, const VkDependencyInfo*                             pDependencyInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_pointer<const VkDependencyInfo>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", 1, dump_text_VkDependencyInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkEvent                                             event, VkPipelineStageFlags2               stageMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkEvent>(event, settings, "VkEvent", "event", 1, dump_text_VkEvent); // MET
        dump_text_value<const VkPipelineStageFlags2>(stageMask, settings, "VkPipelineStageFlags2", "stageMask", 1, dump_text_VkPipelineStageFlags2); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWaitEvents2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, uint32_t                                            eventCount, const VkEvent*                     pEvents, const VkDependencyInfo*            pDependencyInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(eventCount, settings, "uint32_t", "eventCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkEvent>(pEvents, eventCount, settings, "const VkEvent*", "const VkEvent", "pEvents", 1, dump_text_VkEvent); // HQA
        dump_text_array<const VkDependencyInfo>(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "const VkDependencyInfo", "pDependencyInfos", 1, dump_text_VkDependencyInfo); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPipelineBarrier2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, const VkDependencyInfo*                             pDependencyInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkDependencyInfo>(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", 1, dump_text_VkDependencyInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteTimestamp2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, VkPipelineStageFlags2               stage, VkQueryPool                                         queryPool, uint32_t                                            query)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineStageFlags2>(stage, settings, "VkPipelineStageFlags2", "stage", 1, dump_text_VkPipelineStageFlags2); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(query, settings, "uint32_t", "query", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueSubmit2KHR(ApiDumpInstance& dump_inst, VkResult result, VkQueue                           queue, uint32_t                            submitCount, const VkSubmitInfo2*              pSubmits, VkFence           fence)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_value<const uint32_t>(submitCount, settings, "uint32_t", "submitCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkSubmitInfo2>(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "const VkSubmitInfo2", "pSubmits", 1, dump_text_VkSubmitInfo2); // HQA
        dump_text_value<const VkFence>(fence, settings, "VkFence", "fence", 1, dump_text_VkFence); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSetLayout>(layout, settings, "VkDescriptorSetLayout", "layout", 1, dump_text_VkDescriptorSetLayout); // MET
        dump_text_pointer<const VkDeviceSize>(pLayoutSizeInBytes, settings, "VkDeviceSize*", "pLayoutSizeInBytes", 1, dump_text_VkDeviceSize);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSetLayout>(layout, settings, "VkDescriptorSetLayout", "layout", 1, dump_text_VkDescriptorSetLayout); // MET
        dump_text_value<const uint32_t>(binding, settings, "uint32_t", "binding", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkDeviceSize>(pOffset, settings, "VkDeviceSize*", "pOffset", 1, dump_text_VkDeviceSize);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorGetInfoEXT>(pDescriptorInfo, settings, "const VkDescriptorGetInfoEXT*", "pDescriptorInfo", 1, dump_text_VkDescriptorGetInfoEXT);
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pDescriptor, settings, "void*", "pDescriptor", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(bufferCount, settings, "uint32_t", "bufferCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkDescriptorBufferBindingInfoEXT>(pBindingInfos, bufferCount, settings, "const VkDescriptorBufferBindingInfoEXT*", "const VkDescriptorBufferBindingInfoEXT", "pBindingInfos", 1, dump_text_VkDescriptorBufferBindingInfoEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(firstSet, settings, "uint32_t", "firstSet", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(setCount, settings, "uint32_t", "setCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const uint32_t>(pBufferIndices, setCount, settings, "const uint32_t*", "const uint32_t", "pBufferIndices", 1, dump_text_uint32_t); // HQA
        dump_text_array<const VkDeviceSize>(pOffsets, setCount, settings, "const VkDeviceSize*", "const VkDeviceSize", "pOffsets", 1, dump_text_VkDeviceSize); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipelineLayout>(layout, settings, "VkPipelineLayout", "layout", 1, dump_text_VkPipelineLayout); // MET
        dump_text_value<const uint32_t>(set, settings, "uint32_t", "set", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferCaptureDescriptorDataInfoEXT>(pInfo, settings, "const VkBufferCaptureDescriptorDataInfoEXT*", "pInfo", 1, dump_text_VkBufferCaptureDescriptorDataInfoEXT);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageCaptureDescriptorDataInfoEXT>(pInfo, settings, "const VkImageCaptureDescriptorDataInfoEXT*", "pInfo", 1, dump_text_VkImageCaptureDescriptorDataInfoEXT);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImageViewCaptureDescriptorDataInfoEXT>(pInfo, settings, "const VkImageViewCaptureDescriptorDataInfoEXT*", "pInfo", 1, dump_text_VkImageViewCaptureDescriptorDataInfoEXT);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSamplerCaptureDescriptorDataInfoEXT>(pInfo, settings, "const VkSamplerCaptureDescriptorDataInfoEXT*", "pInfo", 1, dump_text_VkSamplerCaptureDescriptorDataInfoEXT);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAccelerationStructureCaptureDescriptorDataInfoEXT>(pInfo, settings, "const VkAccelerationStructureCaptureDescriptorDataInfoEXT*", "pInfo", 1, dump_text_VkAccelerationStructureCaptureDescriptorDataInfoEXT);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance& dump_inst, VkCommandBuffer           commandBuffer, VkFragmentShadingRateNV                     shadingRate, const VkFragmentShadingRateCombinerOpKHR    combinerOps[2])
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkFragmentShadingRateNV>(shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", 1, dump_text_VkFragmentShadingRateNV); // MET
        dump_text_array<const VkFragmentShadingRateCombinerOpKHR>(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "const VkFragmentShadingRateCombinerOpKHR", "combinerOps", 1, dump_text_VkFragmentShadingRateCombinerOpKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkBuffer>(countBuffer, settings, "VkBuffer", "countBuffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const uint32_t>(maxDrawCount, settings, "uint32_t", "maxDrawCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyBufferInfo2>(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", 1, dump_text_VkCopyBufferInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyImageInfo2>(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", 1, dump_text_VkCopyImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyBufferToImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyBufferToImageInfo2>(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", 1, dump_text_VkCopyBufferToImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyImageToBufferInfo2>(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", 1, dump_text_VkCopyImageToBufferInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBlitImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBlitImageInfo2>(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", 1, dump_text_VkBlitImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdResolveImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkResolveImageInfo2>(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", 1, dump_text_VkResolveImageInfo2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceFaultInfoEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceFaultCountsEXT>(pFaultCounts, settings, "VkDeviceFaultCountsEXT*", "pFaultCounts", 1, dump_text_VkDeviceFaultCountsEXT);
        dump_text_pointer<const VkDeviceFaultInfoEXT>(pFaultInfo, settings, "VkDeviceFaultInfoEXT*", "pFaultInfo", 1, dump_text_VkDeviceFaultInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkAcquireWinrtDisplayNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, VkDisplayKHR display)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const VkDisplayKHR>(display, settings, "VkDisplayKHR", "display", 1, dump_text_VkDisplayKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_WIN32_KHR)
void dump_text_vkGetWinrtDisplayNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(deviceRelativeId, settings, "uint32_t", "deviceRelativeId", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const VkDisplayKHR>(pDisplay, settings, "VkDisplayKHR*", "pDisplay", 1, dump_text_VkDisplayKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_WIN32_KHR
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_vkCreateDirectFBSurfaceEXT(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkDirectFBSurfaceCreateInfoEXT>(pCreateInfo, settings, "const VkDirectFBSurfaceCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkDirectFBSurfaceCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
void dump_text_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const IDirectFB>(dfb, settings, "IDirectFB*", "dfb", 1, dump_text_IDirectFB);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_DIRECTFB_EXT
void dump_text_vkCmdTraceRaysKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_value<const uint32_t>(width, settings, "uint32_t", "width", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(height, settings, "uint32_t", "height", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(depth, settings, "uint32_t", "depth", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateRayTracingPipelinesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_value<const VkPipelineCache>(pipelineCache, settings, "VkPipelineCache", "pipelineCache", 1, dump_text_VkPipelineCache); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkRayTracingPipelineCreateInfoKHR>(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoKHR*", "const VkRayTracingPipelineCreateInfoKHR", "pCreateInfos", 1, dump_text_VkRayTracingPipelineCreateInfoKHR); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkPipeline>(pPipelines, createInfoCount, settings, "VkPipeline*", "VkPipeline", "pPipelines", 1, dump_text_VkPipeline); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(firstGroup, settings, "uint32_t", "firstGroup", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCount, settings, "uint32_t", "groupCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdTraceRaysIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_pointer<const VkStridedDeviceAddressRegionKHR>(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", 1, dump_text_VkStridedDeviceAddressRegionKHR);
        dump_text_value<const VkDeviceAddress>(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", 1, dump_text_VkDeviceAddress); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance& dump_inst, VkDeviceSize result, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceSize(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
        dump_text_value<const uint32_t>(group, settings, "uint32_t", "group", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkShaderGroupShaderKHR>(groupShader, settings, "VkShaderGroupShaderKHR", "groupShader", 1, dump_text_VkShaderGroupShaderKHR); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(pipelineStackSize, settings, "uint32_t", "pipelineStackSize", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetVertexInputEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkVertexInputBindingDescription2EXT>(pVertexBindingDescriptions, vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription2EXT*", "const VkVertexInputBindingDescription2EXT", "pVertexBindingDescriptions", 1, dump_text_VkVertexInputBindingDescription2EXT); // HQA
        dump_text_value<const uint32_t>(vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkVertexInputAttributeDescription2EXT>(pVertexAttributeDescriptions, vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription2EXT*", "const VkVertexInputAttributeDescription2EXT", "pVertexAttributeDescriptions", 1, dump_text_VkVertexInputAttributeDescription2EXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetZirconHandleInfoFUCHSIA>(pGetZirconHandleInfo, settings, "const VkMemoryGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", 1, dump_text_VkMemoryGetZirconHandleInfoFUCHSIA);
        dump_text_pointer<const zx_handle_t>(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", 1, dump_text_zx_handle_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagBits); // MET
        dump_text_value<const zx_handle_t>(zirconHandle, settings, "zx_handle_t", "zirconHandle", 1, dump_text_zx_handle_t); // MET
        dump_text_pointer<const VkMemoryZirconHandlePropertiesFUCHSIA>(pMemoryZirconHandleProperties, settings, "VkMemoryZirconHandlePropertiesFUCHSIA*", "pMemoryZirconHandleProperties", 1, dump_text_VkMemoryZirconHandlePropertiesFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkImportSemaphoreZirconHandleInfoFUCHSIA>(pImportSemaphoreZirconHandleInfo, settings, "const VkImportSemaphoreZirconHandleInfoFUCHSIA*", "pImportSemaphoreZirconHandleInfo", 1, dump_text_VkImportSemaphoreZirconHandleInfoFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkSemaphoreGetZirconHandleInfoFUCHSIA>(pGetZirconHandleInfo, settings, "const VkSemaphoreGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", 1, dump_text_VkSemaphoreGetZirconHandleInfoFUCHSIA);
        dump_text_pointer<const zx_handle_t>(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", 1, dump_text_zx_handle_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkBufferCollectionCreateInfoFUCHSIA>(pCreateInfo, settings, "const VkBufferCollectionCreateInfoFUCHSIA*", "pCreateInfo", 1, dump_text_VkBufferCollectionCreateInfoFUCHSIA);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkBufferCollectionFUCHSIA>(pCollection, settings, "VkBufferCollectionFUCHSIA*", "pCollection", 1, dump_text_VkBufferCollectionFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBufferCollectionFUCHSIA>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", 1, dump_text_VkBufferCollectionFUCHSIA); // MET
        dump_text_pointer<const VkImageConstraintsInfoFUCHSIA>(pImageConstraintsInfo, settings, "const VkImageConstraintsInfoFUCHSIA*", "pImageConstraintsInfo", 1, dump_text_VkImageConstraintsInfoFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBufferCollectionFUCHSIA>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", 1, dump_text_VkBufferCollectionFUCHSIA); // MET
        dump_text_pointer<const VkBufferConstraintsInfoFUCHSIA>(pBufferConstraintsInfo, settings, "const VkBufferConstraintsInfoFUCHSIA*", "pBufferConstraintsInfo", 1, dump_text_VkBufferConstraintsInfoFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBufferCollectionFUCHSIA>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", 1, dump_text_VkBufferCollectionFUCHSIA); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
#if defined(VK_USE_PLATFORM_FUCHSIA)
void dump_text_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkBufferCollectionFUCHSIA>(collection, settings, "VkBufferCollectionFUCHSIA", "collection", 1, dump_text_VkBufferCollectionFUCHSIA); // MET
        dump_text_pointer<const VkBufferCollectionPropertiesFUCHSIA>(pProperties, settings, "VkBufferCollectionPropertiesFUCHSIA*", "pProperties", 1, dump_text_VkBufferCollectionPropertiesFUCHSIA);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_FUCHSIA
void dump_text_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkRenderPass>(renderpass, settings, "VkRenderPass", "renderpass", 1, dump_text_VkRenderPass); // MET
        dump_text_array<const VkExtent2D>(pMaxWorkgroupSize, 1, settings, "VkExtent2D*", "VkExtent2D", "pMaxWorkgroupSize", 1, dump_text_VkExtent2D); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSubpassShadingHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImageView>(imageView, settings, "VkImageView", "imageView", 1, dump_text_VkImageView); // MET
        dump_text_value<const VkImageLayout>(imageLayout, settings, "VkImageLayout", "imageLayout", 1, dump_text_VkImageLayout); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetMemoryRemoteAddressNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetRemoteAddressInfoNV>(pMemoryGetRemoteAddressInfo, settings, "const VkMemoryGetRemoteAddressInfoNV*", "pMemoryGetRemoteAddressInfo", 1, dump_text_VkMemoryGetRemoteAddressInfoNV);
        dump_text_pointer<const VkRemoteAddressNV>(pAddress, settings, "VkRemoteAddressNV*", "pAddress", 1, dump_text_VkRemoteAddressNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelinePropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineInfoKHR>(pPipelineInfo, settings, "const VkPipelineInfoEXT*", "pPipelineInfo", 1, dump_text_VkPipelineInfoKHR);
        dump_text_pointer<const VkBaseOutStructure>(pPipelineProperties, settings, "VkBaseOutStructure*", "pPipelineProperties", 1, dump_text_VkBaseOutStructure);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPatchControlPointsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(patchControlPoints, settings, "uint32_t", "patchControlPoints", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLogicOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLogicOp logicOp)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkLogicOp>(logicOp, settings, "VkLogicOp", "logicOp", 1, dump_text_VkLogicOp); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_vkCreateScreenSurfaceQNX(ApiDumpInstance& dump_inst, VkResult result, VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkInstance>(instance, settings, "VkInstance", "instance", 1, dump_text_VkInstance); // MET
        dump_text_pointer<const VkScreenSurfaceCreateInfoQNX>(pCreateInfo, settings, "const VkScreenSurfaceCreateInfoQNX*", "pCreateInfo", 1, dump_text_VkScreenSurfaceCreateInfoQNX);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkSurfaceKHR>(pSurface, settings, "VkSurfaceKHR*", "pSurface", 1, dump_text_VkSurfaceKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance& dump_inst, VkBool32 result, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkBool32(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_value<const uint32_t>(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", 1, dump_text_uint32_t); // MET
        dump_text_value<const _screen_window*>(window, settings, "struct _screen_window*", "window", 1, dump_text__screen_window); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
void dump_text_vkCmdSetColorWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer       commandBuffer, uint32_t                                attachmentCount, const VkBool32*   pColorWriteEnables)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBool32>(pColorWriteEnables, attachmentCount, settings, "const VkBool32*", "const VkBool32", "pColorWriteEnables", 1, dump_text_VkBool32); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", 1, dump_text_VkDeviceAddress); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMultiEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMultiDrawInfoEXT>(pVertexInfo, drawCount, settings, "const VkMultiDrawInfoEXT*", "const VkMultiDrawInfoEXT", "pVertexInfo", 1, dump_text_VkMultiDrawInfoEXT); // HQA
        dump_text_value<const uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawMultiIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(drawCount, settings, "uint32_t", "drawCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMultiDrawIndexedInfoEXT>(pIndexInfo, drawCount, settings, "const VkMultiDrawIndexedInfoEXT*", "const VkMultiDrawIndexedInfoEXT", "pIndexInfo", 1, dump_text_VkMultiDrawIndexedInfoEXT); // HQA
        dump_text_value<const uint32_t>(instanceCount, settings, "uint32_t", "instanceCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(firstInstance, settings, "uint32_t", "firstInstance", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
        dump_text_pointer<const int32_t>(pVertexOffset, settings, "const int32_t*", "pVertexOffset", 1, dump_text_int32_t);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateMicromapEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                           device, const VkMicromapCreateInfoEXT*        pCreateInfo, const VkAllocationCallbacks*       pAllocator, VkMicromapEXT*                        pMicromap)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMicromapCreateInfoEXT>(pCreateInfo, settings, "const VkMicromapCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkMicromapCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkMicromapEXT>(pMicromap, settings, "VkMicromapEXT*", "pMicromap", 1, dump_text_VkMicromapEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkMicromapEXT>(micromap, settings, "VkMicromapEXT", "micromap", 1, dump_text_VkMicromapEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer                                    commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMicromapBuildInfoEXT>(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "const VkMicromapBuildInfoEXT", "pInfos", 1, dump_text_VkMicromapBuildInfoEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice                                           device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMicromapBuildInfoEXT>(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "const VkMicromapBuildInfoEXT", "pInfos", 1, dump_text_VkMicromapBuildInfoEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMicromapEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyMicromapInfoEXT>(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", 1, dump_text_VkCopyMicromapInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyMicromapToMemoryInfoEXT>(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", 1, dump_text_VkCopyMicromapToMemoryInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeferredOperationKHR>(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", 1, dump_text_VkDeferredOperationKHR); // MET
        dump_text_pointer<const VkCopyMemoryToMicromapInfoEXT>(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", 1, dump_text_VkCopyMemoryToMicromapInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType  queryType, size_t       dataSize, void* pData, size_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(micromapCount, settings, "uint32_t", "micromapCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMicromapEXT>(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "const VkMicromapEXT", "pMicromaps", 1, dump_text_VkMicromapEXT); // HQA
        dump_text_value<const VkQueryType>(queryType, settings, "VkQueryType", "queryType", 1, dump_text_VkQueryType); // MET
        dump_text_value<const size_t>(dataSize, settings, "size_t", "dataSize", 1, dump_text_size_t); // MET
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
        dump_text_value<const size_t>(stride, settings, "size_t", "stride", 1, dump_text_size_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyMicromapInfoEXT>(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", 1, dump_text_VkCopyMicromapInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyMicromapToMemoryInfoEXT>(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", 1, dump_text_VkCopyMicromapToMemoryInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkCopyMemoryToMicromapInfoEXT>(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", 1, dump_text_VkCopyMemoryToMicromapInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(micromapCount, settings, "uint32_t", "micromapCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkMicromapEXT>(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "const VkMicromapEXT", "pMicromaps", 1, dump_text_VkMicromapEXT); // HQA
        dump_text_value<const VkQueryType>(queryType, settings, "VkQueryType", "queryType", 1, dump_text_VkQueryType); // MET
        dump_text_value<const VkQueryPool>(queryPool, settings, "VkQueryPool", "queryPool", 1, dump_text_VkQueryPool); // MET
        dump_text_value<const uint32_t>(firstQuery, settings, "uint32_t", "firstQuery", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMicromapVersionInfoEXT>(pVersionInfo, settings, "const VkMicromapVersionInfoEXT*", "pVersionInfo", 1, dump_text_VkMicromapVersionInfoEXT);
        dump_text_pointer<const VkAccelerationStructureCompatibilityKHR>(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", 1, dump_text_VkAccelerationStructureCompatibilityKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetMicromapBuildSizesEXT(ApiDumpInstance& dump_inst, VkDevice                                            device, VkAccelerationStructureBuildTypeKHR                 buildType, const VkMicromapBuildInfoEXT*  pBuildInfo, VkMicromapBuildSizesInfoEXT*           pSizeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkAccelerationStructureBuildTypeKHR>(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", 1, dump_text_VkAccelerationStructureBuildTypeKHR); // MET
        dump_text_pointer<const VkMicromapBuildInfoEXT>(pBuildInfo, settings, "const VkMicromapBuildInfoEXT*", "pBuildInfo", 1, dump_text_VkMicromapBuildInfoEXT);
        dump_text_pointer<const VkMicromapBuildSizesInfoEXT>(pSizeInfo, settings, "VkMicromapBuildSizesInfoEXT*", "pSizeInfo", 1, dump_text_VkMicromapBuildSizesInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawClusterHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(groupCountX, settings, "uint32_t", "groupCountX", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountY, settings, "uint32_t", "groupCountY", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(groupCountZ, settings, "uint32_t", "groupCountZ", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance& dump_inst, VkDevice       device, VkDeviceMemory memory, float          priority)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDeviceMemory>(memory, settings, "VkDeviceMemory", "memory", 1, dump_text_VkDeviceMemory); // MET
        dump_text_value<const float>(priority, settings, "float", "priority", 1, dump_text_float); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceBufferMemoryRequirements>(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceBufferMemoryRequirements);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageMemoryRequirements>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceImageMemoryRequirements);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageMemoryRequirements>(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", 1, dump_text_VkDeviceImageMemoryRequirements);
        dump_text_pointer<const uint32_t>(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", 1, dump_text_uint32_t);
        dump_text_array<const VkSparseImageMemoryRequirements2>(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "VkSparseImageMemoryRequirements2", "pSparseMemoryRequirements", 1, dump_text_VkSparseImageMemoryRequirements2); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDescriptorSetBindingReferenceVALVE>(pBindingReference, settings, "const VkDescriptorSetBindingReferenceVALVE*", "pBindingReference", 1, dump_text_VkDescriptorSetBindingReferenceVALVE);
        dump_text_pointer<const VkDescriptorSetLayoutHostMappingInfoVALVE>(pHostMapping, settings, "VkDescriptorSetLayoutHostMappingInfoVALVE*", "pHostMapping", 1, dump_text_VkDescriptorSetLayoutHostMappingInfoVALVE);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, void** ppData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkDescriptorSet>(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", 1, dump_text_VkDescriptorSet); // MET
        dump_text_pointer<const void*>(ppData, settings, "void**", "ppData", 1, dump_text_void);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMemoryIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const uint32_t>(copyCount, settings, "uint32_t", "copyCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const uint32_t>(copyCount, settings, "uint32_t", "copyCount", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
        dump_text_value<const VkImage>(dstImage, settings, "VkImage", "dstImage", 1, dump_text_VkImage); // MET
        dump_text_value<const VkImageLayout>(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", 1, dump_text_VkImageLayout); // MET
        dump_text_array<const VkImageSubresourceLayers>(pImageSubresources, copyCount, settings, "const VkImageSubresourceLayers*", "const VkImageSubresourceLayers", "pImageSubresources", 1, dump_text_VkImageSubresourceLayers); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDecompressMemoryNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(decompressRegionCount, settings, "uint32_t", "decompressRegionCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkDecompressMemoryRegionNV>(pDecompressMemoryRegions, decompressRegionCount, settings, "const VkDecompressMemoryRegionNV*", "const VkDecompressMemoryRegionNV", "pDecompressMemoryRegions", 1, dump_text_VkDecompressMemoryRegionNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDeviceAddress>(indirectCommandsAddress, settings, "VkDeviceAddress", "indirectCommandsAddress", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const VkDeviceAddress>(indirectCommandsCountAddress, settings, "VkDeviceAddress", "indirectCommandsCountAddress", 1, dump_text_VkDeviceAddress); // MET
        dump_text_value<const uint32_t>(stride, settings, "uint32_t", "stride", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkComputePipelineCreateInfo>(pCreateInfo, settings, "const VkComputePipelineCreateInfo*", "pCreateInfo", 1, dump_text_VkComputePipelineCreateInfo);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint           pipelineBindPoint, VkPipeline                    pipeline)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPipelineBindPoint>(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", 1, dump_text_VkPipelineBindPoint); // MET
        dump_text_value<const VkPipeline>(pipeline, settings, "VkPipeline", "pipeline", 1, dump_text_VkPipeline); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance& dump_inst, VkDeviceAddress result, VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkDeviceAddress(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineIndirectDeviceAddressInfoNV>(pInfo, settings, "const VkPipelineIndirectDeviceAddressInfoNV*", "pInfo", 1, dump_text_VkPipelineIndirectDeviceAddressInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthClampEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthClampEnable, settings, "VkBool32", "depthClampEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetPolygonModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkPolygonMode>(polygonMode, settings, "VkPolygonMode", "polygonMode", 1, dump_text_VkPolygonMode); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits  rasterizationSamples)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkSampleCountFlagBits>(rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", 1, dump_text_VkSampleCountFlagBits); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetSampleMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits  samples, const VkSampleMask*    pSampleMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkSampleCountFlagBits>(samples, settings, "VkSampleCountFlagBits", "samples", 1, dump_text_VkSampleCountFlagBits); // MET
        dump_text_array<const VkSampleMask>(pSampleMask, (samples + 31) / 32, settings, "const VkSampleMask*", "const VkSampleMask", "pSampleMask", 1, dump_text_VkSampleMask); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLogicOpEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(logicOpEnable, settings, "VkBool32", "logicOpEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetColorBlendEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkBool32>(pColorBlendEnables, attachmentCount, settings, "const VkBool32*", "const VkBool32", "pColorBlendEnables", 1, dump_text_VkBool32); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetColorBlendEquationEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkColorBlendEquationEXT>(pColorBlendEquations, attachmentCount, settings, "const VkColorBlendEquationEXT*", "const VkColorBlendEquationEXT", "pColorBlendEquations", 1, dump_text_VkColorBlendEquationEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetColorWriteMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkColorComponentFlags>(pColorWriteMasks, attachmentCount, settings, "const VkColorComponentFlags*", "const VkColorComponentFlags", "pColorWriteMasks", 1, dump_text_VkColorComponentFlags); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkTessellationDomainOrigin>(domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", 1, dump_text_VkTessellationDomainOrigin); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRasterizationStreamEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(rasterizationStream, settings, "uint32_t", "rasterizationStream", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkConservativeRasterizationModeEXT>(conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", 1, dump_text_VkConservativeRasterizationModeEXT); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const float>(extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", 1, dump_text_float); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthClipEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(depthClipEnable, settings, "VkBool32", "depthClipEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstAttachment, settings, "uint32_t", "firstAttachment", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(attachmentCount, settings, "uint32_t", "attachmentCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkColorBlendAdvancedEXT>(pColorBlendAdvanced, attachmentCount, settings, "const VkColorBlendAdvancedEXT*", "const VkColorBlendAdvancedEXT", "pColorBlendAdvanced", 1, dump_text_VkColorBlendAdvancedEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkProvokingVertexModeEXT>(provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", 1, dump_text_VkProvokingVertexModeEXT); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkLineRasterizationMode>(lineRasterizationMode, settings, "VkLineRasterizationModeEXT", "lineRasterizationMode", 1, dump_text_VkLineRasterizationMode); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetLineStippleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(stippledLineEnable, settings, "VkBool32", "stippledLineEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(negativeOneToOne, settings, "VkBool32", "negativeOneToOne", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetViewportSwizzleNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(firstViewport, settings, "uint32_t", "firstViewport", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint32_t>(viewportCount, settings, "uint32_t", "viewportCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkViewportSwizzleNV>(pViewportSwizzles, viewportCount, settings, "const VkViewportSwizzleNV*", "const VkViewportSwizzleNV", "pViewportSwizzles", 1, dump_text_VkViewportSwizzleNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", 1, dump_text_uint32_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageModulationModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCoverageModulationModeNV>(coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", 1, dump_text_VkCoverageModulationModeNV); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageModulationTableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const float>(pCoverageModulationTable, coverageModulationTableCount, settings, "const float*", "const float", "pCoverageModulationTable", 1, dump_text_float); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", 1, dump_text_VkBool32); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetCoverageReductionModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkCoverageReductionModeNV>(coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", 1, dump_text_VkCoverageReductionModeNV); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetShaderModuleIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkShaderModule>(shaderModule, settings, "VkShaderModule", "shaderModule", 1, dump_text_VkShaderModule); // MET
        dump_text_pointer<const VkShaderModuleIdentifierEXT>(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", 1, dump_text_VkShaderModuleIdentifierEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkShaderModuleCreateInfo>(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", 1, dump_text_VkShaderModuleCreateInfo);
        dump_text_pointer<const VkShaderModuleIdentifierEXT>(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", 1, dump_text_VkShaderModuleIdentifierEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const VkOpticalFlowImageFormatInfoNV>(pOpticalFlowImageFormatInfo, settings, "const VkOpticalFlowImageFormatInfoNV*", "pOpticalFlowImageFormatInfo", 1, dump_text_VkOpticalFlowImageFormatInfoNV);
        dump_text_pointer<const uint32_t>(pFormatCount, settings, "uint32_t*", "pFormatCount", 1, dump_text_uint32_t);
        dump_text_array<const VkOpticalFlowImageFormatPropertiesNV>(pImageFormatProperties, *pFormatCount, settings, "VkOpticalFlowImageFormatPropertiesNV*", "VkOpticalFlowImageFormatPropertiesNV", "pImageFormatProperties", 1, dump_text_VkOpticalFlowImageFormatPropertiesNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkOpticalFlowSessionCreateInfoNV>(pCreateInfo, settings, "const VkOpticalFlowSessionCreateInfoNV*", "pCreateInfo", 1, dump_text_VkOpticalFlowSessionCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkOpticalFlowSessionNV>(pSession, settings, "VkOpticalFlowSessionNV*", "pSession", 1, dump_text_VkOpticalFlowSessionNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkOpticalFlowSessionNV>(session, settings, "VkOpticalFlowSessionNV", "session", 1, dump_text_VkOpticalFlowSessionNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkBindOpticalFlowSessionImageNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkOpticalFlowSessionNV>(session, settings, "VkOpticalFlowSessionNV", "session", 1, dump_text_VkOpticalFlowSessionNV); // MET
        dump_text_value<const VkOpticalFlowSessionBindingPointNV>(bindingPoint, settings, "VkOpticalFlowSessionBindingPointNV", "bindingPoint", 1, dump_text_VkOpticalFlowSessionBindingPointNV); // MET
        dump_text_value<const VkImageView>(view, settings, "VkImageView", "view", 1, dump_text_VkImageView); // MET
        dump_text_value<const VkImageLayout>(layout, settings, "VkImageLayout", "layout", 1, dump_text_VkImageLayout); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdOpticalFlowExecuteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkOpticalFlowSessionNV>(session, settings, "VkOpticalFlowSessionNV", "session", 1, dump_text_VkOpticalFlowSessionNV); // MET
        dump_text_pointer<const VkOpticalFlowExecuteInfoNV>(pExecuteInfo, settings, "const VkOpticalFlowExecuteInfoNV*", "pExecuteInfo", 1, dump_text_VkOpticalFlowExecuteInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindIndexBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBuffer>(buffer, settings, "VkBuffer", "buffer", 1, dump_text_VkBuffer); // MET
        dump_text_value<const VkDeviceSize>(offset, settings, "VkDeviceSize", "offset", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkDeviceSize>(size, settings, "VkDeviceSize", "size", 1, dump_text_VkDeviceSize); // MET
        dump_text_value<const VkIndexType>(indexType, settings, "VkIndexType", "indexType", 1, dump_text_VkIndexType); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetRenderingAreaGranularityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderingAreaInfo>(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", 1, dump_text_VkRenderingAreaInfo);
        dump_text_pointer<const VkExtent2D>(pGranularity, settings, "VkExtent2D*", "pGranularity", 1, dump_text_VkExtent2D);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkDeviceImageSubresourceInfo>(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", 1, dump_text_VkDeviceImageSubresourceInfo);
        dump_text_pointer<const VkSubresourceLayout2>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", 1, dump_text_VkSubresourceLayout2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetImageSubresourceLayout2KHR(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkImage>(image, settings, "VkImage", "image", 1, dump_text_VkImage); // MET
        dump_text_pointer<const VkImageSubresource2>(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", 1, dump_text_VkImageSubresource2);
        dump_text_pointer<const VkSubresourceLayout2>(pLayout, settings, "VkSubresourceLayout2*", "pLayout", 1, dump_text_VkSubresourceLayout2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkAntiLagUpdateAMD(ApiDumpInstance& dump_inst, VkDevice device, const VkAntiLagDataAMD* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkAntiLagDataAMD>(pData, settings, "const VkAntiLagDataAMD*", "pData", 1, dump_text_VkAntiLagDataAMD);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateShadersEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const uint32_t>(createInfoCount, settings, "uint32_t", "createInfoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkShaderCreateInfoEXT>(pCreateInfos, createInfoCount, settings, "const VkShaderCreateInfoEXT*", "const VkShaderCreateInfoEXT", "pCreateInfos", 1, dump_text_VkShaderCreateInfoEXT); // HQA
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_array<const VkShaderEXT>(pShaders, createInfoCount, settings, "VkShaderEXT*", "VkShaderEXT", "pShaders", 1, dump_text_VkShaderEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkShaderEXT>(shader, settings, "VkShaderEXT", "shader", 1, dump_text_VkShaderEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetShaderBinaryDataEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkShaderEXT>(shader, settings, "VkShaderEXT", "shader", 1, dump_text_VkShaderEXT); // MET
        dump_text_pointer<const size_t>(pDataSize, settings, "size_t*", "pDataSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindShadersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(stageCount, settings, "uint32_t", "stageCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkShaderStageFlagBits>(pStages, stageCount, settings, "const VkShaderStageFlagBits*", "const VkShaderStageFlagBits", "pStages", 1, dump_text_VkShaderStageFlagBits); // HQA
        dump_text_array<const VkShaderEXT>(pShaders, stageCount, settings, "const VkShaderEXT*", "const VkShaderEXT", "pShaders", 1, dump_text_VkShaderEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDepthClampRangeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkDepthClampModeEXT>(depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", 1, dump_text_VkDepthClampModeEXT); // MET
        dump_text_pointer<const VkDepthClampRangeEXT>(pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", 1, dump_text_VkDepthClampRangeEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreatePipelineBinariesKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineBinaryCreateInfoKHR>(pCreateInfo, settings, "const VkPipelineBinaryCreateInfoKHR*", "pCreateInfo", 1, dump_text_VkPipelineBinaryCreateInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkPipelineBinaryHandlesInfoKHR>(pBinaries, settings, "VkPipelineBinaryHandlesInfoKHR*", "pBinaries", 1, dump_text_VkPipelineBinaryHandlesInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyPipelineBinaryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkPipelineBinaryKHR>(pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", 1, dump_text_VkPipelineBinaryKHR); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineKeyKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineCreateInfoKHR>(pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", 1, dump_text_VkPipelineCreateInfoKHR);
        dump_text_pointer<const VkPipelineBinaryKeyKHR>(pPipelineKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineKey", 1, dump_text_VkPipelineBinaryKeyKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPipelineBinaryDataKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPipelineBinaryDataInfoKHR>(pInfo, settings, "const VkPipelineBinaryDataInfoKHR*", "pInfo", 1, dump_text_VkPipelineBinaryDataInfoKHR);
        dump_text_pointer<const VkPipelineBinaryKeyKHR>(pPipelineBinaryKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineBinaryKey", 1, dump_text_VkPipelineBinaryKeyKHR);
        dump_text_pointer<const size_t>(pPipelineBinaryDataSize, settings, "size_t*", "pPipelineBinaryDataSize", 1, dump_text_size_t);
        dump_text_value<const void*>(pPipelineBinaryData, settings, "void*", "pPipelineBinaryData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkReleaseCapturedPipelineDataInfoKHR>(pInfo, settings, "const VkReleaseCapturedPipelineDataInfoKHR*", "pInfo", 1, dump_text_VkReleaseCapturedPipelineDataInfoKHR);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkFramebuffer>(framebuffer, settings, "VkFramebuffer", "framebuffer", 1, dump_text_VkFramebuffer); // MET
        dump_text_pointer<const uint32_t>(pPropertiesCount, settings, "uint32_t*", "pPropertiesCount", 1, dump_text_uint32_t);
        dump_text_array<const VkTilePropertiesQCOM>(pProperties, *pPropertiesCount, settings, "VkTilePropertiesQCOM*", "VkTilePropertiesQCOM", "pProperties", 1, dump_text_VkTilePropertiesQCOM); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkRenderingInfo>(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", 1, dump_text_VkRenderingInfo);
        dump_text_pointer<const VkTilePropertiesQCOM>(pProperties, settings, "VkTilePropertiesQCOM*", "pProperties", 1, dump_text_VkTilePropertiesQCOM);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCooperativeVectorPropertiesNV>(pProperties, *pPropertyCount, settings, "VkCooperativeVectorPropertiesNV*", "VkCooperativeVectorPropertiesNV", "pProperties", 1, dump_text_VkCooperativeVectorPropertiesNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkConvertCooperativeVectorMatrixInfoNV>(pInfo, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfo", 1, dump_text_VkConvertCooperativeVectorMatrixInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(infoCount, settings, "uint32_t", "infoCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkConvertCooperativeVectorMatrixInfoNV>(pInfos, infoCount, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "const VkConvertCooperativeVectorMatrixInfoNV", "pInfos", 1, dump_text_VkConvertCooperativeVectorMatrixInfoNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetLatencySleepModeNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkLatencySleepModeInfoNV>(pSleepModeInfo, settings, "const VkLatencySleepModeInfoNV*", "pSleepModeInfo", 1, dump_text_VkLatencySleepModeInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkLatencySleepNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkLatencySleepInfoNV>(pSleepInfo, settings, "const VkLatencySleepInfoNV*", "pSleepInfo", 1, dump_text_VkLatencySleepInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkSetLatencyMarkerNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkSetLatencyMarkerInfoNV>(pLatencyMarkerInfo, settings, "const VkSetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", 1, dump_text_VkSetLatencyMarkerInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetLatencyTimingsNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkSwapchainKHR>(swapchain, settings, "VkSwapchainKHR", "swapchain", 1, dump_text_VkSwapchainKHR); // MET
        dump_text_pointer<const VkGetLatencyMarkerInfoNV>(pLatencyMarkerInfo, settings, "VkGetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", 1, dump_text_VkGetLatencyMarkerInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkQueueNotifyOutOfBandNV(ApiDumpInstance& dump_inst, VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkQueue>(queue, settings, "VkQueue", "queue", 1, dump_text_VkQueue); // MET
        dump_text_pointer<const VkOutOfBandQueueTypeInfoNV>(pQueueTypeInfo, settings, "const VkOutOfBandQueueTypeInfoNV*", "pQueueTypeInfo", 1, dump_text_VkOutOfBandQueueTypeInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCooperativeMatrixPropertiesKHR>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesKHR*", "VkCooperativeMatrixPropertiesKHR", "pProperties", 1, dump_text_VkCooperativeMatrixPropertiesKHR); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkImageAspectFlags>(aspectMask, settings, "VkImageAspectFlags", "aspectMask", 1, dump_text_VkImageAspectFlags); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
void dump_text_vkGetScreenBufferPropertiesQNX(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const _screen_buffer*>(buffer, settings, "const struct _screen_buffer*", "buffer", 1, dump_text__screen_buffer); // MET
        dump_text_pointer<const VkScreenBufferPropertiesQNX>(pProperties, settings, "VkScreenBufferPropertiesQNX*", "pProperties", 1, dump_text_VkScreenBufferPropertiesQNX);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_SCREEN_QNX
void dump_text_vkCmdSetLineStippleKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const uint32_t>(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", 1, dump_text_uint32_t); // MET
        dump_text_value<const uint16_t>(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", 1, dump_text_uint16_t); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorSets2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo*   pBindDescriptorSetsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBindDescriptorSetsInfo>(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", 1, dump_text_VkBindDescriptorSetsInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushConstants2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo*        pPushConstantsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushConstantsInfo>(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", 1, dump_text_VkPushConstantsInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSet2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo*    pPushDescriptorSetInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushDescriptorSetInfo>(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", 1, dump_text_VkPushDescriptorSetInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkPushDescriptorSetWithTemplateInfo>(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", 1, dump_text_VkPushDescriptorSetWithTemplateInfo);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkSetDescriptorBufferOffsetsInfoEXT>(pSetDescriptorBufferOffsetsInfo, settings, "const VkSetDescriptorBufferOffsetsInfoEXT*", "pSetDescriptorBufferOffsetsInfo", 1, dump_text_VkSetDescriptorBufferOffsetsInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT>(pBindDescriptorBufferEmbeddedSamplersInfo, settings, "const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*", "pBindDescriptorBufferEmbeddedSamplersInfo", 1, dump_text_VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBindTileMemoryQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkTileMemoryBindInfoQCOM>(pTileMemoryBindInfo, settings, "const VkTileMemoryBindInfoQCOM*", "pTileMemoryBindInfo", 1, dump_text_VkTileMemoryBindInfoQCOM);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkExternalComputeQueueCreateInfoNV>(pCreateInfo, settings, "const VkExternalComputeQueueCreateInfoNV*", "pCreateInfo", 1, dump_text_VkExternalComputeQueueCreateInfoNV);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkExternalComputeQueueNV>(pExternalQueue, settings, "VkExternalComputeQueueNV*", "pExternalQueue", 1, dump_text_VkExternalComputeQueueNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalComputeQueueNV>(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", 1, dump_text_VkExternalComputeQueueNV); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetExternalComputeQueueDataNV(ApiDumpInstance& dump_inst, VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkExternalComputeQueueNV>(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", 1, dump_text_VkExternalComputeQueueNV); // MET
        dump_text_pointer<const VkExternalComputeQueueDataParamsNV>(params, settings, "VkExternalComputeQueueDataParamsNV*", "params", 1, dump_text_VkExternalComputeQueueDataParamsNV);
        dump_text_value<const void*>(pData, settings, "void*", "pData", 1, dump_text_void); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkClusterAccelerationStructureInputInfoNV>(pInfo, settings, "const VkClusterAccelerationStructureInputInfoNV*", "pInfo", 1, dump_text_VkClusterAccelerationStructureInputInfoNV);
        dump_text_pointer<const VkAccelerationStructureBuildSizesInfoKHR>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", 1, dump_text_VkAccelerationStructureBuildSizesInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer                     commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV*  pCommandInfos)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkClusterAccelerationStructureCommandsInfoNV>(pCommandInfos, settings, "const VkClusterAccelerationStructureCommandsInfoNV*", "pCommandInfos", 1, dump_text_VkClusterAccelerationStructureCommandsInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR*                  pSizeInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkPartitionedAccelerationStructureInstancesInputNV>(pInfo, settings, "const VkPartitionedAccelerationStructureInstancesInputNV*", "pInfo", 1, dump_text_VkPartitionedAccelerationStructureInstancesInputNV);
        dump_text_pointer<const VkAccelerationStructureBuildSizesInfoKHR>(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", 1, dump_text_VkAccelerationStructureBuildSizesInfoKHR);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance& dump_inst, VkCommandBuffer                     commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV*  pBuildInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkBuildPartitionedAccelerationStructureInfoNV>(pBuildInfo, settings, "const VkBuildPartitionedAccelerationStructureInfoNV*", "pBuildInfo", 1, dump_text_VkBuildPartitionedAccelerationStructureInfoNV);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkGeneratedCommandsMemoryRequirementsInfoEXT>(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoEXT*", "pInfo", 1, dump_text_VkGeneratedCommandsMemoryRequirementsInfoEXT);
        dump_text_pointer<const VkMemoryRequirements2>(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", 1, dump_text_VkMemoryRequirements2);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkGeneratedCommandsInfoEXT>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", 1, dump_text_VkGeneratedCommandsInfoEXT);
        dump_text_value<const VkCommandBuffer>(stateCommandBuffer, settings, "VkCommandBuffer", "stateCommandBuffer", 1, dump_text_VkCommandBuffer); // MET
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_value<const VkBool32>(isPreprocessed, settings, "VkBool32", "isPreprocessed", 1, dump_text_VkBool32); // MET
        dump_text_pointer<const VkGeneratedCommandsInfoEXT>(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", 1, dump_text_VkGeneratedCommandsInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkIndirectCommandsLayoutCreateInfoEXT>(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkIndirectCommandsLayoutCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkIndirectCommandsLayoutEXT>(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT*", "pIndirectCommandsLayout", 1, dump_text_VkIndirectCommandsLayoutEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkIndirectCommandsLayoutEXT>(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", 1, dump_text_VkIndirectCommandsLayoutEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkCreateIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkIndirectExecutionSetCreateInfoEXT>(pCreateInfo, settings, "const VkIndirectExecutionSetCreateInfoEXT*", "pCreateInfo", 1, dump_text_VkIndirectExecutionSetCreateInfoEXT);
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
        dump_text_pointer<const VkIndirectExecutionSetEXT>(pIndirectExecutionSet, settings, "VkIndirectExecutionSetEXT*", "pIndirectExecutionSet", 1, dump_text_VkIndirectExecutionSetEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkIndirectExecutionSetEXT>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", 1, dump_text_VkIndirectExecutionSetEXT); // MET
        dump_text_pointer<const VkAllocationCallbacks>(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", 1, dump_text_VkAllocationCallbacks);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkIndirectExecutionSetEXT>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", 1, dump_text_VkIndirectExecutionSetEXT); // MET
        dump_text_value<const uint32_t>(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkWriteIndirectExecutionSetPipelineEXT>(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetPipelineEXT*", "const VkWriteIndirectExecutionSetPipelineEXT", "pExecutionSetWrites", 1, dump_text_VkWriteIndirectExecutionSetPipelineEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkIndirectExecutionSetEXT>(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", 1, dump_text_VkIndirectExecutionSetEXT); // MET
        dump_text_value<const uint32_t>(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", 1, dump_text_uint32_t); // MET
        dump_text_array<const VkWriteIndirectExecutionSetShaderEXT>(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetShaderEXT*", "const VkWriteIndirectExecutionSetShaderEXT", "pExecutionSetWrites", 1, dump_text_VkWriteIndirectExecutionSetShaderEXT); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
void dump_text_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance& dump_inst, VkResult result, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkPhysicalDevice>(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", 1, dump_text_VkPhysicalDevice); // MET
        dump_text_pointer<const uint32_t>(pPropertyCount, settings, "uint32_t*", "pPropertyCount", 1, dump_text_uint32_t);
        dump_text_array<const VkCooperativeMatrixFlexibleDimensionsPropertiesNV>(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*", "VkCooperativeMatrixFlexibleDimensionsPropertiesNV", "pProperties", 1, dump_text_VkCooperativeMatrixFlexibleDimensionsPropertiesNV); // HQA
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_vkGetMemoryMetalHandleEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_pointer<const VkMemoryGetMetalHandleInfoEXT>(pGetMetalHandleInfo, settings, "const VkMemoryGetMetalHandleInfoEXT*", "pGetMetalHandleInfo", 1, dump_text_VkMemoryGetMetalHandleInfoEXT);
        dump_text_pointer<const void*>(pHandle, settings, "void**", "pHandle", 1, dump_text_void);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_METAL_EXT
#if defined(VK_USE_PLATFORM_METAL_EXT)
void dump_text_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance& dump_inst, VkResult result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << " ";
    dump_text_VkResult(result, settings, 0);
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkDevice>(device, settings, "VkDevice", "device", 1, dump_text_VkDevice); // MET
        dump_text_value<const VkExternalMemoryHandleTypeFlagBits>(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", 1, dump_text_VkExternalMemoryHandleTypeFlagBits); // MET
        dump_text_value<const void*>(pHandle, settings, "const void*", "pHandle", 1, dump_text_void); // MET
        dump_text_pointer<const VkMemoryMetalHandlePropertiesEXT>(pMemoryMetalHandleProperties, settings, "VkMemoryMetalHandlePropertiesEXT*", "pMemoryMetalHandleProperties", 1, dump_text_VkMemoryMetalHandlePropertiesEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}
#endif // VK_USE_PLATFORM_METAL_EXT
void dump_text_vkCmdEndRendering2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer                   commandBuffer, const VkRenderingEndInfoEXT*        pRenderingEndInfo)
{
    const ApiDumpSettings& settings(dump_inst.settings());
    settings.stream() << ":\n";
    if(settings.showParams())
    {
        dump_text_value<const VkCommandBuffer>(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", 1, dump_text_VkCommandBuffer); // MET
        dump_text_pointer<const VkRenderingEndInfoEXT>(pRenderingEndInfo, settings, "const VkRenderingEndInfoEXT*", "pRenderingEndInfo", 1, dump_text_VkRenderingEndInfoEXT);
    }
    settings.shouldFlush() ? settings.stream() << std::endl : settings.stream() << "\n";
}


