DIAG: *******************************************
DIAG:   Registry.apiGen file: parameter_validation.h api: vulkan profile: None
DIAG: *******************************************
DIAG: *** Including extension VK_KHR_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_KHR_win32_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_ANDROID_native_buffer (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_EXT_debug_report (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_glsl_shader (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_NV_extension_1 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_KHR_sampler_mirror_clamp_to_edge (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_IMG_filter_cubic (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_AMD_extension_17 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_18 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_AMD_rasterization_order (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_KHR_swapchain (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_AMD_extension_20 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_AMD_shader_trinary_minmax (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_AMD_shader_explicit_vertex_parameter (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_EXT_debug_marker (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_AMD_extension_24 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_25 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_AMD_gcn_shader (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_dedicated_allocation (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_EXT_extension_28 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NVX_extension_29 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_KHR_display (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_NVX_extension_30 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NVX_extension_31 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_32 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_33 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_AMD_draw_indirect_count (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_AMD_extension_35 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_36 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_37 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_38 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_39 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_KHR_display_swapchain (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_AMD_extension_40 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_41 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_42 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_43 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_44 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_45 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_46 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_AMD_extension_47 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NVX_extension_48 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_GOOGLE_extension_49 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_KHR_xlib_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_GOOGLE_extension_50 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NVX_extension_51 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NVX_extension_52 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NV_extension_53 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_NV_extension_54 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_IMG_format_pvrtc (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_external_memory_capabilities (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_external_memory (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_external_memory_win32 (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_NV_win32_keyed_mutex (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_KHR_xcb_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** NOT including extension VK_KHR_extension_60 (does not match api attribute or explicitly requested extensions)
DIAG: *** NOT including extension VK_KHR_extension_61 (does not match api attribute or explicitly requested extensions)
DIAG: *** Including extension VK_KHR_wayland_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_KHR_mir_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** Including extension VK_KHR_android_surface (defaultExtensions matches the 'supported' attribute)
DIAG: *** PASS 1: TAG FEATURES ********************************************
DIAG: *** PASS 1: Tagging required and removed features for VK_VERSION_1_0
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VK_API_VERSION -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_MAKE_VERSION
DIAG: *** tagging type: VK_MAKE_VERSION -> required = True
DIAG: *** tagging type: VK_API_VERSION_1_0 -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_MAKE_VERSION
DIAG: *** tagging type: VK_MAKE_VERSION -> required = True
DIAG: *** tagging type: VK_VERSION_MAJOR -> required = True
DIAG: *** tagging type: VK_VERSION_MINOR -> required = True
DIAG: *** tagging type: VK_VERSION_PATCH -> required = True
DIAG: *** tagging type: VK_HEADER_VERSION -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VK_NULL_HANDLE -> required = True
DIAG: *** tagging type: VkPipelineCacheHeaderVersion -> required = True
DIAG: *** tagging enum: VK_LOD_CLAMP_NONE -> required = True
DIAG: *** tagging enum: VK_REMAINING_MIP_LEVELS -> required = True
DIAG: *** tagging enum: VK_REMAINING_ARRAY_LAYERS -> required = True
DIAG: *** tagging enum: VK_WHOLE_SIZE -> required = True
DIAG: *** tagging enum: VK_ATTACHMENT_UNUSED -> required = True
DIAG: *** tagging enum: VK_TRUE -> required = True
DIAG: *** tagging enum: VK_FALSE -> required = True
DIAG: *** tagging enum: VK_QUEUE_FAMILY_IGNORED -> required = True
DIAG: *** tagging enum: VK_SUBPASS_EXTERNAL -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateInstance -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstanceCreateInfo
DIAG: *** tagging type: VkInstanceCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInstanceCreateFlags
DIAG: *** tagging type: VkInstanceCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkApplicationInfo
DIAG: *** tagging type: VkApplicationInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyInstance -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkEnumeratePhysicalDevices -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceFeatures -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDeviceFeatures
DIAG: *** tagging type: VkPhysicalDeviceFeatures -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceFormatProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFormatProperties
DIAG: *** tagging type: VkFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlags -> required = True
DIAG: *** Generating dependent type VkFormatFeatureFlagBits for type VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlags -> required = True
DIAG: *** Generating dependent type VkFormatFeatureFlagBits for type VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlags -> required = True
DIAG: *** Generating dependent type VkFormatFeatureFlagBits for type VkFormatFeatureFlags
DIAG: *** tagging type: VkFormatFeatureFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceImageFormatProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageType
DIAG: *** tagging type: VkImageType -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageTiling
DIAG: *** tagging type: VkImageTiling -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlags -> required = True
DIAG: *** Generating dependent type VkImageCreateFlagBits for type VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageFormatProperties
DIAG: *** tagging type: VkImageFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDeviceProperties
DIAG: *** tagging type: VkPhysicalDeviceProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPhysicalDeviceType
DIAG: *** tagging type: VkPhysicalDeviceType -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint8_t
DIAG: *** tagging type: uint8_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint8_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPhysicalDeviceLimits
DIAG: *** tagging type: VkPhysicalDeviceLimits -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPhysicalDeviceSparseProperties
DIAG: *** tagging type: VkPhysicalDeviceSparseProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
DIAG: *** tagging enum: VK_MAX_PHYSICAL_DEVICE_NAME_SIZE -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_UUID_SIZE
DIAG: *** tagging enum: VK_UUID_SIZE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceQueueFamilyProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueueFamilyProperties
DIAG: *** tagging type: VkQueueFamilyProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueueFlags
DIAG: *** tagging type: VkQueueFlags -> required = True
DIAG: *** Generating dependent type VkQueueFlagBits for type VkQueueFlags
DIAG: *** tagging type: VkQueueFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceMemoryProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDeviceMemoryProperties
DIAG: *** tagging type: VkPhysicalDeviceMemoryProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMemoryType
DIAG: *** tagging type: VkMemoryType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMemoryPropertyFlags
DIAG: *** tagging type: VkMemoryPropertyFlags -> required = True
DIAG: *** Generating dependent type VkMemoryPropertyFlagBits for type VkMemoryPropertyFlags
DIAG: *** tagging type: VkMemoryPropertyFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMemoryHeap
DIAG: *** tagging type: VkMemoryHeap -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMemoryHeapFlags
DIAG: *** tagging type: VkMemoryHeapFlags -> required = True
DIAG: *** Generating dependent type VkMemoryHeapFlagBits for type VkMemoryHeapFlags
DIAG: *** tagging type: VkMemoryHeapFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_MEMORY_TYPES
DIAG: *** tagging enum: VK_MAX_MEMORY_TYPES -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_MEMORY_HEAPS
DIAG: *** tagging enum: VK_MAX_MEMORY_HEAPS -> required = True
DIAG: *** tagging command: vkGetInstanceProcAddr -> required = True
DIAG: *** markRequired: command implicitly requires dependent type PFN_vkVoidFunction
DIAG: *** tagging type: PFN_vkVoidFunction -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetDeviceProcAddr -> required = True
DIAG: *** markRequired: command implicitly requires dependent type PFN_vkVoidFunction
DIAG: *** tagging type: PFN_vkVoidFunction -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateDevice -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceCreateInfo
DIAG: *** tagging type: VkDeviceCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceCreateFlags
DIAG: *** tagging type: VkDeviceCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceQueueCreateInfo
DIAG: *** tagging type: VkDeviceQueueCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceQueueCreateFlags
DIAG: *** tagging type: VkDeviceQueueCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPhysicalDeviceFeatures
DIAG: *** tagging type: VkPhysicalDeviceFeatures -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyDevice -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkEnumerateInstanceExtensionProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExtensionProperties
DIAG: *** tagging type: VkExtensionProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** tagging enum: VK_MAX_EXTENSION_NAME_SIZE -> required = True
DIAG: *** tagging command: vkEnumerateDeviceExtensionProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExtensionProperties
DIAG: *** tagging type: VkExtensionProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** tagging enum: VK_MAX_EXTENSION_NAME_SIZE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkEnumerateInstanceLayerProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkLayerProperties
DIAG: *** tagging type: VkLayerProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** tagging enum: VK_MAX_EXTENSION_NAME_SIZE -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_DESCRIPTION_SIZE
DIAG: *** tagging enum: VK_MAX_DESCRIPTION_SIZE -> required = True
DIAG: *** tagging command: vkEnumerateDeviceLayerProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkLayerProperties
DIAG: *** tagging type: VkLayerProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** tagging enum: VK_MAX_EXTENSION_NAME_SIZE -> required = True
DIAG: *** markRequired: type requires dependent <enum> VK_MAX_DESCRIPTION_SIZE
DIAG: *** tagging enum: VK_MAX_DESCRIPTION_SIZE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkGetDeviceQueue -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueue
DIAG: *** tagging type: VkQueue -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkQueueSubmit -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueue
DIAG: *** tagging type: VkQueue -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSubmitInfo
DIAG: *** tagging type: VkSubmitInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkQueueWaitIdle -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueue
DIAG: *** tagging type: VkQueue -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkDeviceWaitIdle -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkAllocateMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryAllocateInfo
DIAG: *** tagging type: VkMemoryAllocateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkFreeMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkMapMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryMapFlags
DIAG: *** tagging type: VkMemoryMapFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkUnmapMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkFlushMappedMemoryRanges -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMappedMemoryRange
DIAG: *** tagging type: VkMappedMemoryRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkInvalidateMappedMemoryRanges -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMappedMemoryRange
DIAG: *** tagging type: VkMappedMemoryRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetDeviceMemoryCommitment -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkBindBufferMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkBindImageMemory -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetBufferMemoryRequirements -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryRequirements
DIAG: *** tagging type: VkMemoryRequirements -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetImageMemoryRequirements -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryRequirements
DIAG: *** tagging type: VkMemoryRequirements -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkGetImageSparseMemoryRequirements -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSparseImageMemoryRequirements
DIAG: *** tagging type: VkSparseImageMemoryRequirements -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageFormatProperties
DIAG: *** tagging type: VkSparseImageFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageFormatFlags
DIAG: *** tagging type: VkSparseImageFormatFlags -> required = True
DIAG: *** Generating dependent type VkSparseImageFormatFlagBits for type VkSparseImageFormatFlags
DIAG: *** tagging type: VkSparseImageFormatFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceSparseImageFormatProperties -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageType
DIAG: *** tagging type: VkImageType -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSampleCountFlagBits
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageTiling
DIAG: *** tagging type: VkImageTiling -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSparseImageFormatProperties
DIAG: *** tagging type: VkSparseImageFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageFormatFlags
DIAG: *** tagging type: VkSparseImageFormatFlags -> required = True
DIAG: *** Generating dependent type VkSparseImageFormatFlagBits for type VkSparseImageFormatFlags
DIAG: *** tagging type: VkSparseImageFormatFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkQueueBindSparse -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueue
DIAG: *** tagging type: VkQueue -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBindSparseInfo
DIAG: *** tagging type: VkBindSparseInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseBufferMemoryBindInfo
DIAG: *** tagging type: VkSparseBufferMemoryBindInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseMemoryBind
DIAG: *** tagging type: VkSparseMemoryBind -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlags -> required = True
DIAG: *** Generating dependent type VkSparseMemoryBindFlagBits for type VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageOpaqueMemoryBindInfo
DIAG: *** tagging type: VkSparseImageOpaqueMemoryBindInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseMemoryBind
DIAG: *** tagging type: VkSparseMemoryBind -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlags -> required = True
DIAG: *** Generating dependent type VkSparseMemoryBindFlagBits for type VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageMemoryBindInfo
DIAG: *** tagging type: VkSparseImageMemoryBindInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseImageMemoryBind
DIAG: *** tagging type: VkSparseImageMemoryBind -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresource
DIAG: *** tagging type: VkImageSubresource -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlags -> required = True
DIAG: *** Generating dependent type VkSparseMemoryBindFlagBits for type VkSparseMemoryBindFlags
DIAG: *** tagging type: VkSparseMemoryBindFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateFence -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFenceCreateInfo
DIAG: *** tagging type: VkFenceCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFenceCreateFlags
DIAG: *** tagging type: VkFenceCreateFlags -> required = True
DIAG: *** Generating dependent type VkFenceCreateFlagBits for type VkFenceCreateFlags
DIAG: *** tagging type: VkFenceCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyFence -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkResetFences -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetFenceStatus -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkWaitForFences -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateSemaphore -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSemaphoreCreateInfo
DIAG: *** tagging type: VkSemaphoreCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphoreCreateFlags
DIAG: *** tagging type: VkSemaphoreCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroySemaphore -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEventCreateInfo
DIAG: *** tagging type: VkEventCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkEventCreateFlags
DIAG: *** tagging type: VkEventCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetEventStatus -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkSetEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkResetEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateQueryPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPoolCreateInfo
DIAG: *** tagging type: VkQueryPoolCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueryPoolCreateFlags
DIAG: *** tagging type: VkQueryPoolCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueryType
DIAG: *** tagging type: VkQueryType -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueryPipelineStatisticFlags
DIAG: *** tagging type: VkQueryPipelineStatisticFlags -> required = True
DIAG: *** Generating dependent type VkQueryPipelineStatisticFlagBits for type VkQueryPipelineStatisticFlags
DIAG: *** tagging type: VkQueryPipelineStatisticFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyQueryPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetQueryPoolResults -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryResultFlags
DIAG: *** tagging type: VkQueryResultFlags -> required = True
DIAG: *** Generating dependent type VkQueryResultFlagBits for type VkQueryResultFlags
DIAG: *** tagging type: VkQueryResultFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferCreateInfo
DIAG: *** tagging type: VkBufferCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBufferCreateFlags
DIAG: *** tagging type: VkBufferCreateFlags -> required = True
DIAG: *** Generating dependent type VkBufferCreateFlagBits for type VkBufferCreateFlags
DIAG: *** tagging type: VkBufferCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBufferUsageFlags
DIAG: *** tagging type: VkBufferUsageFlags -> required = True
DIAG: *** Generating dependent type VkBufferUsageFlagBits for type VkBufferUsageFlags
DIAG: *** tagging type: VkBufferUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSharingMode
DIAG: *** tagging type: VkSharingMode -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateBufferView -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferViewCreateInfo
DIAG: *** tagging type: VkBufferViewCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBufferViewCreateFlags
DIAG: *** tagging type: VkBufferViewCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferView
DIAG: *** tagging type: VkBufferView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyBufferView -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferView
DIAG: *** tagging type: VkBufferView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageCreateInfo
DIAG: *** tagging type: VkImageCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlags -> required = True
DIAG: *** Generating dependent type VkImageCreateFlagBits for type VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageType
DIAG: *** tagging type: VkImageType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlagBits
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageTiling
DIAG: *** tagging type: VkImageTiling -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSharingMode
DIAG: *** tagging type: VkSharingMode -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetImageSubresourceLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageSubresource
DIAG: *** tagging type: VkImageSubresource -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSubresourceLayout
DIAG: *** tagging type: VkSubresourceLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateImageView -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageViewCreateInfo
DIAG: *** tagging type: VkImageViewCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageViewCreateFlags
DIAG: *** tagging type: VkImageViewCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageViewType
DIAG: *** tagging type: VkImageViewType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkComponentMapping
DIAG: *** tagging type: VkComponentMapping -> required = True
DIAG: *** markRequired: type requires dependent <type> VkComponentSwizzle
DIAG: *** tagging type: VkComponentSwizzle -> required = True
DIAG: *** markRequired: type requires dependent <type> VkComponentSwizzle
DIAG: *** tagging type: VkComponentSwizzle -> required = True
DIAG: *** markRequired: type requires dependent <type> VkComponentSwizzle
DIAG: *** tagging type: VkComponentSwizzle -> required = True
DIAG: *** markRequired: type requires dependent <type> VkComponentSwizzle
DIAG: *** tagging type: VkComponentSwizzle -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageView
DIAG: *** tagging type: VkImageView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyImageView -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageView
DIAG: *** tagging type: VkImageView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateShaderModule -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkShaderModuleCreateInfo
DIAG: *** tagging type: VkShaderModuleCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderModuleCreateFlags
DIAG: *** tagging type: VkShaderModuleCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkShaderModule
DIAG: *** tagging type: VkShaderModule -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyShaderModule -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkShaderModule
DIAG: *** tagging type: VkShaderModule -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreatePipelineCache -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCacheCreateInfo
DIAG: *** tagging type: VkPipelineCacheCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineCacheCreateFlags
DIAG: *** tagging type: VkPipelineCacheCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyPipelineCache -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetPipelineCacheData -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkMergePipelineCaches -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateGraphicsPipelines -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkGraphicsPipelineCreateInfo
DIAG: *** tagging type: VkGraphicsPipelineCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineCreateFlags
DIAG: *** tagging type: VkPipelineCreateFlags -> required = True
DIAG: *** Generating dependent type VkPipelineCreateFlagBits for type VkPipelineCreateFlags
DIAG: *** tagging type: VkPipelineCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineShaderStageCreateInfo
DIAG: *** tagging type: VkPipelineShaderStageCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineShaderStageCreateFlags
DIAG: *** tagging type: VkPipelineShaderStageCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderStageFlagBits
DIAG: *** tagging type: VkShaderStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderModule
DIAG: *** tagging type: VkShaderModule -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSpecializationInfo
DIAG: *** tagging type: VkSpecializationInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSpecializationMapEntry
DIAG: *** tagging type: VkSpecializationMapEntry -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineVertexInputStateCreateInfo
DIAG: *** tagging type: VkPipelineVertexInputStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineVertexInputStateCreateFlags
DIAG: *** tagging type: VkPipelineVertexInputStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkVertexInputBindingDescription
DIAG: *** tagging type: VkVertexInputBindingDescription -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkVertexInputRate
DIAG: *** tagging type: VkVertexInputRate -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkVertexInputAttributeDescription
DIAG: *** tagging type: VkVertexInputAttributeDescription -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineInputAssemblyStateCreateInfo
DIAG: *** tagging type: VkPipelineInputAssemblyStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineInputAssemblyStateCreateFlags
DIAG: *** tagging type: VkPipelineInputAssemblyStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPrimitiveTopology
DIAG: *** tagging type: VkPrimitiveTopology -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineTessellationStateCreateInfo
DIAG: *** tagging type: VkPipelineTessellationStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineTessellationStateCreateFlags
DIAG: *** tagging type: VkPipelineTessellationStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineViewportStateCreateInfo
DIAG: *** tagging type: VkPipelineViewportStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineViewportStateCreateFlags
DIAG: *** tagging type: VkPipelineViewportStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkViewport
DIAG: *** tagging type: VkViewport -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineRasterizationStateCreateInfo
DIAG: *** tagging type: VkPipelineRasterizationStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineRasterizationStateCreateFlags
DIAG: *** tagging type: VkPipelineRasterizationStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPolygonMode
DIAG: *** tagging type: VkPolygonMode -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCullModeFlags
DIAG: *** tagging type: VkCullModeFlags -> required = True
DIAG: *** Generating dependent type VkCullModeFlagBits for type VkCullModeFlags
DIAG: *** tagging type: VkCullModeFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFrontFace
DIAG: *** tagging type: VkFrontFace -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineMultisampleStateCreateInfo
DIAG: *** tagging type: VkPipelineMultisampleStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineMultisampleStateCreateFlags
DIAG: *** tagging type: VkPipelineMultisampleStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlagBits
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleMask
DIAG: *** tagging type: VkSampleMask -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineDepthStencilStateCreateInfo
DIAG: *** tagging type: VkPipelineDepthStencilStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineDepthStencilStateCreateFlags
DIAG: *** tagging type: VkPipelineDepthStencilStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompareOp
DIAG: *** tagging type: VkCompareOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOpState
DIAG: *** tagging type: VkStencilOpState -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompareOp
DIAG: *** tagging type: VkCompareOp -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOpState
DIAG: *** tagging type: VkStencilOpState -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStencilOp
DIAG: *** tagging type: VkStencilOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompareOp
DIAG: *** tagging type: VkCompareOp -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineColorBlendStateCreateInfo
DIAG: *** tagging type: VkPipelineColorBlendStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineColorBlendStateCreateFlags
DIAG: *** tagging type: VkPipelineColorBlendStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkLogicOp
DIAG: *** tagging type: VkLogicOp -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineColorBlendAttachmentState
DIAG: *** tagging type: VkPipelineColorBlendAttachmentState -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendFactor
DIAG: *** tagging type: VkBlendFactor -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendFactor
DIAG: *** tagging type: VkBlendFactor -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendOp
DIAG: *** tagging type: VkBlendOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendFactor
DIAG: *** tagging type: VkBlendFactor -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendFactor
DIAG: *** tagging type: VkBlendFactor -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBlendOp
DIAG: *** tagging type: VkBlendOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkColorComponentFlags
DIAG: *** tagging type: VkColorComponentFlags -> required = True
DIAG: *** Generating dependent type VkColorComponentFlagBits for type VkColorComponentFlags
DIAG: *** tagging type: VkColorComponentFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineDynamicStateCreateInfo
DIAG: *** tagging type: VkPipelineDynamicStateCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineDynamicStateCreateFlags
DIAG: *** tagging type: VkPipelineDynamicStateCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDynamicState
DIAG: *** tagging type: VkDynamicState -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkCreateComputePipelines -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineCache
DIAG: *** tagging type: VkPipelineCache -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkComputePipelineCreateInfo
DIAG: *** tagging type: VkComputePipelineCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineCreateFlags
DIAG: *** tagging type: VkPipelineCreateFlags -> required = True
DIAG: *** Generating dependent type VkPipelineCreateFlagBits for type VkPipelineCreateFlags
DIAG: *** tagging type: VkPipelineCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineShaderStageCreateInfo
DIAG: *** tagging type: VkPipelineShaderStageCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineShaderStageCreateFlags
DIAG: *** tagging type: VkPipelineShaderStageCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderStageFlagBits
DIAG: *** tagging type: VkShaderStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderModule
DIAG: *** tagging type: VkShaderModule -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSpecializationInfo
DIAG: *** tagging type: VkSpecializationInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSpecializationMapEntry
DIAG: *** tagging type: VkSpecializationMapEntry -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyPipeline -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreatePipelineLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineLayoutCreateInfo
DIAG: *** tagging type: VkPipelineLayoutCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineLayoutCreateFlags
DIAG: *** tagging type: VkPipelineLayoutCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSetLayout
DIAG: *** tagging type: VkDescriptorSetLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPushConstantRange
DIAG: *** tagging type: VkPushConstantRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlags -> required = True
DIAG: *** Generating dependent type VkShaderStageFlagBits for type VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyPipelineLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateSampler -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSamplerCreateInfo
DIAG: *** tagging type: VkSamplerCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSamplerCreateFlags
DIAG: *** tagging type: VkSamplerCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFilter
DIAG: *** tagging type: VkFilter -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFilter
DIAG: *** tagging type: VkFilter -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSamplerMipmapMode
DIAG: *** tagging type: VkSamplerMipmapMode -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSamplerAddressMode
DIAG: *** tagging type: VkSamplerAddressMode -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSamplerAddressMode
DIAG: *** tagging type: VkSamplerAddressMode -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSamplerAddressMode
DIAG: *** tagging type: VkSamplerAddressMode -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompareOp
DIAG: *** tagging type: VkCompareOp -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBorderColor
DIAG: *** tagging type: VkBorderColor -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSampler
DIAG: *** tagging type: VkSampler -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroySampler -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSampler
DIAG: *** tagging type: VkSampler -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateDescriptorSetLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSetLayoutCreateInfo
DIAG: *** tagging type: VkDescriptorSetLayoutCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSetLayoutCreateFlags
DIAG: *** tagging type: VkDescriptorSetLayoutCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSetLayoutBinding
DIAG: *** tagging type: VkDescriptorSetLayoutBinding -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorType
DIAG: *** tagging type: VkDescriptorType -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlags -> required = True
DIAG: *** Generating dependent type VkShaderStageFlagBits for type VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampler
DIAG: *** tagging type: VkSampler -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSetLayout
DIAG: *** tagging type: VkDescriptorSetLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyDescriptorSetLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSetLayout
DIAG: *** tagging type: VkDescriptorSetLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkCreateDescriptorPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPoolCreateInfo
DIAG: *** tagging type: VkDescriptorPoolCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorPoolCreateFlags
DIAG: *** tagging type: VkDescriptorPoolCreateFlags -> required = True
DIAG: *** Generating dependent type VkDescriptorPoolCreateFlagBits for type VkDescriptorPoolCreateFlags
DIAG: *** tagging type: VkDescriptorPoolCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorPoolSize
DIAG: *** tagging type: VkDescriptorPoolSize -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorType
DIAG: *** tagging type: VkDescriptorType -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPool
DIAG: *** tagging type: VkDescriptorPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyDescriptorPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPool
DIAG: *** tagging type: VkDescriptorPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkResetDescriptorPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPool
DIAG: *** tagging type: VkDescriptorPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPoolResetFlags
DIAG: *** tagging type: VkDescriptorPoolResetFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkAllocateDescriptorSets -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSetAllocateInfo
DIAG: *** tagging type: VkDescriptorSetAllocateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorPool
DIAG: *** tagging type: VkDescriptorPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSetLayout
DIAG: *** tagging type: VkDescriptorSetLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkFreeDescriptorSets -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorPool
DIAG: *** tagging type: VkDescriptorPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkUpdateDescriptorSets -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkWriteDescriptorSet
DIAG: *** tagging type: VkWriteDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorType
DIAG: *** tagging type: VkDescriptorType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorImageInfo
DIAG: *** tagging type: VkDescriptorImageInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampler
DIAG: *** tagging type: VkSampler -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageView
DIAG: *** tagging type: VkImageView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorBufferInfo
DIAG: *** tagging type: VkDescriptorBufferInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBufferView
DIAG: *** tagging type: VkBufferView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCopyDescriptorSet
DIAG: *** tagging type: VkCopyDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateFramebuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFramebufferCreateInfo
DIAG: *** tagging type: VkFramebufferCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFramebufferCreateFlags
DIAG: *** tagging type: VkFramebufferCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageView
DIAG: *** tagging type: VkImageView -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFramebuffer
DIAG: *** tagging type: VkFramebuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyFramebuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFramebuffer
DIAG: *** tagging type: VkFramebuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkCreateRenderPass -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRenderPassCreateInfo
DIAG: *** tagging type: VkRenderPassCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRenderPassCreateFlags
DIAG: *** tagging type: VkRenderPassCreateFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentDescription
DIAG: *** tagging type: VkAttachmentDescription -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentDescriptionFlags
DIAG: *** tagging type: VkAttachmentDescriptionFlags -> required = True
DIAG: *** Generating dependent type VkAttachmentDescriptionFlagBits for type VkAttachmentDescriptionFlags
DIAG: *** tagging type: VkAttachmentDescriptionFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlagBits
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentLoadOp
DIAG: *** tagging type: VkAttachmentLoadOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentStoreOp
DIAG: *** tagging type: VkAttachmentStoreOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentLoadOp
DIAG: *** tagging type: VkAttachmentLoadOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentStoreOp
DIAG: *** tagging type: VkAttachmentStoreOp -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSubpassDescription
DIAG: *** tagging type: VkSubpassDescription -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSubpassDescriptionFlags
DIAG: *** tagging type: VkSubpassDescriptionFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineBindPoint
DIAG: *** tagging type: VkPipelineBindPoint -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentReference
DIAG: *** tagging type: VkAttachmentReference -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentReference
DIAG: *** tagging type: VkAttachmentReference -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentReference
DIAG: *** tagging type: VkAttachmentReference -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAttachmentReference
DIAG: *** tagging type: VkAttachmentReference -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSubpassDependency
DIAG: *** tagging type: VkSubpassDependency -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDependencyFlags
DIAG: *** tagging type: VkDependencyFlags -> required = True
DIAG: *** Generating dependent type VkDependencyFlagBits for type VkDependencyFlags
DIAG: *** tagging type: VkDependencyFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyRenderPass -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetRenderAreaGranularity -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCreateCommandPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPoolCreateInfo
DIAG: *** tagging type: VkCommandPoolCreateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandPoolCreateFlags
DIAG: *** tagging type: VkCommandPoolCreateFlags -> required = True
DIAG: *** Generating dependent type VkCommandPoolCreateFlagBits for type VkCommandPoolCreateFlags
DIAG: *** tagging type: VkCommandPoolCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPool
DIAG: *** tagging type: VkCommandPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyCommandPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPool
DIAG: *** tagging type: VkCommandPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkResetCommandPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPool
DIAG: *** tagging type: VkCommandPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPoolResetFlags
DIAG: *** tagging type: VkCommandPoolResetFlags -> required = True
DIAG: *** Generating dependent type VkCommandPoolResetFlagBits for type VkCommandPoolResetFlags
DIAG: *** tagging type: VkCommandPoolResetFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkAllocateCommandBuffers -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBufferAllocateInfo
DIAG: *** tagging type: VkCommandBufferAllocateInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandPool
DIAG: *** tagging type: VkCommandPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandBufferLevel
DIAG: *** tagging type: VkCommandBufferLevel -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkFreeCommandBuffers -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandPool
DIAG: *** tagging type: VkCommandPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkBeginCommandBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBufferBeginInfo
DIAG: *** tagging type: VkCommandBufferBeginInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandBufferUsageFlags
DIAG: *** tagging type: VkCommandBufferUsageFlags -> required = True
DIAG: *** Generating dependent type VkCommandBufferUsageFlagBits for type VkCommandBufferUsageFlags
DIAG: *** tagging type: VkCommandBufferUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCommandBufferInheritanceInfo
DIAG: *** tagging type: VkCommandBufferInheritanceInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFramebuffer
DIAG: *** tagging type: VkFramebuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueryControlFlags
DIAG: *** tagging type: VkQueryControlFlags -> required = True
DIAG: *** Generating dependent type VkQueryControlFlagBits for type VkQueryControlFlags
DIAG: *** tagging type: VkQueryControlFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkQueryPipelineStatisticFlags
DIAG: *** tagging type: VkQueryPipelineStatisticFlags -> required = True
DIAG: *** Generating dependent type VkQueryPipelineStatisticFlagBits for type VkQueryPipelineStatisticFlags
DIAG: *** tagging type: VkQueryPipelineStatisticFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkEndCommandBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkResetCommandBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBufferResetFlags
DIAG: *** tagging type: VkCommandBufferResetFlags -> required = True
DIAG: *** Generating dependent type VkCommandBufferResetFlagBits for type VkCommandBufferResetFlags
DIAG: *** tagging type: VkCommandBufferResetFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging command: vkCmdBindPipeline -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineBindPoint
DIAG: *** tagging type: VkPipelineBindPoint -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipeline
DIAG: *** tagging type: VkPipeline -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkCmdSetViewport -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkViewport
DIAG: *** tagging type: VkViewport -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetScissor -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetLineWidth -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetDepthBias -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetBlendConstants -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetDepthBounds -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetStencilCompareMask -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlags -> required = True
DIAG: *** Generating dependent type VkStencilFaceFlagBits for type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetStencilWriteMask -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlags -> required = True
DIAG: *** Generating dependent type VkStencilFaceFlagBits for type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetStencilReference -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlags -> required = True
DIAG: *** Generating dependent type VkStencilFaceFlagBits for type VkStencilFaceFlags
DIAG: *** tagging type: VkStencilFaceFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdBindDescriptorSets -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineBindPoint
DIAG: *** tagging type: VkPipelineBindPoint -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDescriptorSet
DIAG: *** tagging type: VkDescriptorSet -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdBindIndexBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkIndexType
DIAG: *** tagging type: VkIndexType -> required = True
DIAG: *** tagging command: vkCmdBindVertexBuffers -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDraw -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDrawIndexed -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDrawIndirect -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDrawIndexedIndirect -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDispatch -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDispatchIndirect -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdCopyBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferCopy
DIAG: *** tagging type: VkBufferCopy -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdCopyImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageCopy
DIAG: *** tagging type: VkImageCopy -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdBlitImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageBlit
DIAG: *** tagging type: VkImageBlit -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFilter
DIAG: *** tagging type: VkFilter -> required = True
DIAG: *** tagging command: vkCmdCopyBufferToImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferImageCopy
DIAG: *** tagging type: VkBufferImageCopy -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdCopyImageToBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferImageCopy
DIAG: *** tagging type: VkBufferImageCopy -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdUpdateBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdFillBuffer -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdClearColorImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkClearColorValue
DIAG: *** tagging type: VkClearColorValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdClearDepthStencilImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkClearDepthStencilValue
DIAG: *** tagging type: VkClearDepthStencilValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdClearAttachments -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkClearAttachment
DIAG: *** tagging type: VkClearAttachment -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearValue
DIAG: *** tagging type: VkClearValue -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearColorValue
DIAG: *** tagging type: VkClearColorValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearDepthStencilValue
DIAG: *** tagging type: VkClearDepthStencilValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkClearRect
DIAG: *** tagging type: VkClearRect -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdResolveImage -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageResolve
DIAG: *** tagging type: VkImageResolve -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceLayers
DIAG: *** tagging type: VkImageSubresourceLayers -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset3D
DIAG: *** tagging type: VkOffset3D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdSetEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdResetEvent -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdWaitEvents -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkEvent
DIAG: *** tagging type: VkEvent -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryBarrier
DIAG: *** tagging type: VkMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferMemoryBarrier
DIAG: *** tagging type: VkBufferMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageMemoryBarrier
DIAG: *** tagging type: VkImageMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdPipelineBarrier -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlags -> required = True
DIAG: *** Generating dependent type VkPipelineStageFlagBits for type VkPipelineStageFlags
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDependencyFlags
DIAG: *** tagging type: VkDependencyFlags -> required = True
DIAG: *** Generating dependent type VkDependencyFlagBits for type VkDependencyFlags
DIAG: *** tagging type: VkDependencyFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMemoryBarrier
DIAG: *** tagging type: VkMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBufferMemoryBarrier
DIAG: *** tagging type: VkBufferMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageMemoryBarrier
DIAG: *** tagging type: VkImageMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdBeginQuery -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryControlFlags
DIAG: *** tagging type: VkQueryControlFlags -> required = True
DIAG: *** Generating dependent type VkQueryControlFlagBits for type VkQueryControlFlags
DIAG: *** tagging type: VkQueryControlFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdEndQuery -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdResetQueryPool -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdWriteTimestamp -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineStageFlagBits
DIAG: *** tagging type: VkPipelineStageFlagBits -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdCopyQueryPoolResults -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryPool
DIAG: *** tagging type: VkQueryPool -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueryResultFlags
DIAG: *** tagging type: VkQueryResultFlags -> required = True
DIAG: *** Generating dependent type VkQueryResultFlagBits for type VkQueryResultFlags
DIAG: *** tagging type: VkQueryResultFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdPushConstants -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPipelineLayout
DIAG: *** tagging type: VkPipelineLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlags -> required = True
DIAG: *** Generating dependent type VkShaderStageFlagBits for type VkShaderStageFlags
DIAG: *** tagging type: VkShaderStageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdBeginRenderPass -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkRenderPassBeginInfo
DIAG: *** tagging type: VkRenderPassBeginInfo -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRenderPass
DIAG: *** tagging type: VkRenderPass -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFramebuffer
DIAG: *** tagging type: VkFramebuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearValue
DIAG: *** tagging type: VkClearValue -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearColorValue
DIAG: *** tagging type: VkClearColorValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkClearDepthStencilValue
DIAG: *** tagging type: VkClearDepthStencilValue -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSubpassContents
DIAG: *** tagging type: VkSubpassContents -> required = True
DIAG: *** tagging command: vkCmdNextSubpass -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSubpassContents
DIAG: *** tagging type: VkSubpassContents -> required = True
DIAG: *** tagging command: vkCmdEndRenderPass -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkCmdExecuteCommands -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkBufferMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDispatchIndirectCommand -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDrawIndexedIndirectCommand -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDrawIndirectCommand -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkImageMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageLayout
DIAG: *** tagging type: VkImageLayout -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageSubresourceRange
DIAG: *** tagging type: VkImageSubresourceRange -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlags -> required = True
DIAG: *** Generating dependent type VkImageAspectFlagBits for type VkImageAspectFlags
DIAG: *** tagging type: VkImageAspectFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkMemoryBarrier -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAccessFlags
DIAG: *** tagging type: VkAccessFlags -> required = True
DIAG: *** Generating dependent type VkAccessFlagBits for type VkAccessFlags
DIAG: *** tagging type: VkAccessFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_KHR_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_ERROR_SURFACE_LOST_KHR -> required = True
DIAG: *** tagging enum: VK_ERROR_NATIVE_WINDOW_IN_USE_KHR -> required = True
DIAG: *** tagging enum: VK_COLORSPACE_SRGB_NONLINEAR_KHR -> required = True
DIAG: *** tagging command: vkDestroySurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceSurfaceSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceSurfaceCapabilitiesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceCapabilitiesKHR
DIAG: *** tagging type: VkSurfaceCapabilitiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagsKHR -> required = True
DIAG: *** Generating dependent type VkSurfaceTransformFlagBitsKHR for type VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompositeAlphaFlagsKHR
DIAG: *** tagging type: VkCompositeAlphaFlagsKHR -> required = True
DIAG: *** Generating dependent type VkCompositeAlphaFlagBitsKHR for type VkCompositeAlphaFlagsKHR
DIAG: *** tagging type: VkCompositeAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceSurfaceFormatsKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceFormatKHR
DIAG: *** tagging type: VkSurfaceFormatKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkColorSpaceKHR
DIAG: *** tagging type: VkColorSpaceKHR -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceSurfacePresentModesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPresentModeKHR
DIAG: *** tagging type: VkPresentModeKHR -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_swapchain
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_KHR_SWAPCHAIN_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_SWAPCHAIN_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_PRESENT_INFO_KHR -> required = True
DIAG: *** tagging enum: VK_IMAGE_LAYOUT_PRESENT_SRC_KHR -> required = True
DIAG: *** tagging enum: VK_SUBOPTIMAL_KHR -> required = True
DIAG: *** tagging enum: VK_ERROR_OUT_OF_DATE_KHR -> required = True
DIAG: *** tagging command: vkCreateSwapchainKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainCreateInfoKHR
DIAG: *** tagging type: VkSwapchainCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSwapchainCreateFlagsKHR
DIAG: *** tagging type: VkSwapchainCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkColorSpaceKHR
DIAG: *** tagging type: VkColorSpaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSharingMode
DIAG: *** tagging type: VkSharingMode -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompositeAlphaFlagBitsKHR
DIAG: *** tagging type: VkCompositeAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPresentModeKHR
DIAG: *** tagging type: VkPresentModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroySwapchainKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkGetSwapchainImagesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkAcquireNextImageKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFence
DIAG: *** tagging type: VkFence -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkQueuePresentKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkQueue
DIAG: *** tagging type: VkQueue -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPresentInfoKHR
DIAG: *** tagging type: VkPresentInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSemaphore
DIAG: *** tagging type: VkSemaphore -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_display
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagsKHR -> required = True
DIAG: *** Generating dependent type VkDisplayPlaneAlphaFlagBitsKHR for type VkDisplayPlaneAlphaFlagsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** tagging type: VkDisplayPropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagsKHR -> required = True
DIAG: *** Generating dependent type VkSurfaceTransformFlagBitsKHR for type VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayModeParametersKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayModePropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeParametersKHR
DIAG: *** tagging type: VkDisplayModeParametersKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayModeCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeCreateFlagsKHR
DIAG: *** tagging type: VkDisplayModeCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeParametersKHR
DIAG: *** tagging type: VkDisplayModeParametersKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayPlaneCapabilitiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayPlaneAlphaFlagsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagsKHR -> required = True
DIAG: *** Generating dependent type VkDisplayPlaneAlphaFlagBitsKHR for type VkDisplayPlaneAlphaFlagsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplayPlanePropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDisplaySurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplaySurfaceCreateFlagsKHR
DIAG: *** tagging type: VkDisplaySurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayPlaneAlphaFlagBitsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_KHR_DISPLAY_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_DISPLAY_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceDisplayPropertiesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayPropertiesKHR
DIAG: *** tagging type: VkDisplayPropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagsKHR -> required = True
DIAG: *** Generating dependent type VkSurfaceTransformFlagBitsKHR for type VkSurfaceTransformFlagsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceDisplayPlanePropertiesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayPlanePropertiesKHR
DIAG: *** tagging type: VkDisplayPlanePropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkGetDisplayPlaneSupportedDisplaysKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetDisplayModePropertiesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayModePropertiesKHR
DIAG: *** tagging type: VkDisplayModePropertiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeParametersKHR
DIAG: *** tagging type: VkDisplayModeParametersKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCreateDisplayModeKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayKHR
DIAG: *** tagging type: VkDisplayKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayModeCreateInfoKHR
DIAG: *** tagging type: VkDisplayModeCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeCreateFlagsKHR
DIAG: *** tagging type: VkDisplayModeCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeParametersKHR
DIAG: *** tagging type: VkDisplayModeParametersKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetDisplayPlaneCapabilitiesKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplayPlaneCapabilitiesKHR
DIAG: *** tagging type: VkDisplayPlaneCapabilitiesKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayPlaneAlphaFlagsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagsKHR -> required = True
DIAG: *** Generating dependent type VkDisplayPlaneAlphaFlagBitsKHR for type VkDisplayPlaneAlphaFlagsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCreateDisplayPlaneSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDisplaySurfaceCreateInfoKHR
DIAG: *** tagging type: VkDisplaySurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplaySurfaceCreateFlagsKHR
DIAG: *** tagging type: VkDisplaySurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayModeKHR
DIAG: *** tagging type: VkDisplayModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDisplayPlaneAlphaFlagBitsKHR
DIAG: *** tagging type: VkDisplayPlaneAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_display_swapchain
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkDisplayPresentInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRect2D
DIAG: *** tagging type: VkRect2D -> required = True
DIAG: *** markRequired: type requires dependent <type> VkOffset2D
DIAG: *** tagging type: VkOffset2D -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR -> required = True
DIAG: *** tagging enum: VK_ERROR_INCOMPATIBLE_DISPLAY_KHR -> required = True
DIAG: *** tagging command: vkCreateSharedSwapchainsKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainCreateInfoKHR
DIAG: *** tagging type: VkSwapchainCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSwapchainCreateFlagsKHR
DIAG: *** tagging type: VkSwapchainCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: type requires dependent <type> VkColorSpaceKHR
DIAG: *** tagging type: VkColorSpaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent2D
DIAG: *** tagging type: VkExtent2D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSharingMode
DIAG: *** tagging type: VkSharingMode -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** tagging type: VkSurfaceTransformFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkCompositeAlphaFlagBitsKHR
DIAG: *** tagging type: VkCompositeAlphaFlagBitsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkPresentModeKHR
DIAG: *** tagging type: VkPresentModeKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSwapchainKHR
DIAG: *** tagging type: VkSwapchainKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_xlib_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkXlibSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkXlibSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkXlibSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkXlibSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> Display
DIAG: *** tagging type: Display -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type Display
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** markRequired: type requires dependent <type> Window
DIAG: *** tagging type: Window -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type Window
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** tagging enum: VK_KHR_XLIB_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_XLIB_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateXlibSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkXlibSurfaceCreateInfoKHR
DIAG: *** tagging type: VkXlibSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkXlibSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkXlibSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> Display
DIAG: *** tagging type: Display -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type Display
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** markRequired: type requires dependent <type> Window
DIAG: *** tagging type: Window -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type Window
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceXlibPresentationSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type Display
DIAG: *** tagging type: Display -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type Display
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VisualID
DIAG: *** tagging type: VisualID -> required = True
DIAG: *** Generating dependent type X11/Xlib.h for type VisualID
DIAG: *** tagging type: X11/Xlib.h -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_xcb_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkXcbSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkXcbSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkXcbSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkXcbSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> xcb_connection_t
DIAG: *** tagging type: xcb_connection_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_connection_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** markRequired: type requires dependent <type> xcb_window_t
DIAG: *** tagging type: xcb_window_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_window_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** tagging enum: VK_KHR_XCB_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_XCB_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateXcbSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkXcbSurfaceCreateInfoKHR
DIAG: *** tagging type: VkXcbSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkXcbSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkXcbSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> xcb_connection_t
DIAG: *** tagging type: xcb_connection_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_connection_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** markRequired: type requires dependent <type> xcb_window_t
DIAG: *** tagging type: xcb_window_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_window_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceXcbPresentationSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type xcb_connection_t
DIAG: *** tagging type: xcb_connection_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_connection_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type xcb_visualid_t
DIAG: *** tagging type: xcb_visualid_t -> required = True
DIAG: *** Generating dependent type xcb/xcb.h for type xcb_visualid_t
DIAG: *** tagging type: xcb/xcb.h -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_wayland_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkWaylandSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkWaylandSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkWaylandSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkWaylandSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> wl_display
DIAG: *** tagging type: wl_display -> required = True
DIAG: *** Generating dependent type wayland-client.h for type wl_display
DIAG: *** tagging type: wayland-client.h -> required = True
DIAG: *** markRequired: type requires dependent <type> wl_surface
DIAG: *** tagging type: wl_surface -> required = True
DIAG: *** Generating dependent type wayland-client.h for type wl_surface
DIAG: *** tagging type: wayland-client.h -> required = True
DIAG: *** tagging enum: VK_KHR_WAYLAND_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateWaylandSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkWaylandSurfaceCreateInfoKHR
DIAG: *** tagging type: VkWaylandSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkWaylandSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkWaylandSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> wl_display
DIAG: *** tagging type: wl_display -> required = True
DIAG: *** Generating dependent type wayland-client.h for type wl_display
DIAG: *** tagging type: wayland-client.h -> required = True
DIAG: *** markRequired: type requires dependent <type> wl_surface
DIAG: *** tagging type: wl_surface -> required = True
DIAG: *** Generating dependent type wayland-client.h for type wl_surface
DIAG: *** tagging type: wayland-client.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceWaylandPresentationSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type wl_display
DIAG: *** tagging type: wl_display -> required = True
DIAG: *** Generating dependent type wayland-client.h for type wl_display
DIAG: *** tagging type: wayland-client.h -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_mir_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkMirSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkMirSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMirSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkMirSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> MirConnection
DIAG: *** tagging type: MirConnection -> required = True
DIAG: *** Generating dependent type mir_toolkit/client_types.h for type MirConnection
DIAG: *** tagging type: mir_toolkit/client_types.h -> required = True
DIAG: *** markRequired: type requires dependent <type> MirSurface
DIAG: *** tagging type: MirSurface -> required = True
DIAG: *** Generating dependent type mir_toolkit/client_types.h for type MirSurface
DIAG: *** tagging type: mir_toolkit/client_types.h -> required = True
DIAG: *** tagging enum: VK_KHR_MIR_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_MIR_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateMirSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkMirSurfaceCreateInfoKHR
DIAG: *** tagging type: VkMirSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkMirSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkMirSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> MirConnection
DIAG: *** tagging type: MirConnection -> required = True
DIAG: *** Generating dependent type mir_toolkit/client_types.h for type MirConnection
DIAG: *** tagging type: mir_toolkit/client_types.h -> required = True
DIAG: *** markRequired: type requires dependent <type> MirSurface
DIAG: *** tagging type: MirSurface -> required = True
DIAG: *** Generating dependent type mir_toolkit/client_types.h for type MirSurface
DIAG: *** tagging type: mir_toolkit/client_types.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceMirPresentationSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type MirConnection
DIAG: *** tagging type: MirConnection -> required = True
DIAG: *** Generating dependent type mir_toolkit/client_types.h for type MirConnection
DIAG: *** tagging type: mir_toolkit/client_types.h -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_android_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkAndroidSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkAndroidSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAndroidSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkAndroidSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> ANativeWindow
DIAG: *** tagging type: ANativeWindow -> required = True
DIAG: *** Generating dependent type android/native_window.h for type ANativeWindow
DIAG: *** tagging type: android/native_window.h -> required = True
DIAG: *** tagging enum: VK_KHR_ANDROID_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_ANDROID_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateAndroidSurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAndroidSurfaceCreateInfoKHR
DIAG: *** tagging type: VkAndroidSurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkAndroidSurfaceCreateFlagsKHR
DIAG: *** tagging type: VkAndroidSurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> ANativeWindow
DIAG: *** tagging type: ANativeWindow -> required = True
DIAG: *** Generating dependent type android/native_window.h for type ANativeWindow
DIAG: *** tagging type: android/native_window.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_win32_surface
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkWin32SurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkWin32SurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkWin32SurfaceCreateFlagsKHR
DIAG: *** tagging type: VkWin32SurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> HINSTANCE
DIAG: *** tagging type: HINSTANCE -> required = True
DIAG: *** Generating dependent type windows.h for type HINSTANCE
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** markRequired: type requires dependent <type> HWND
DIAG: *** tagging type: HWND -> required = True
DIAG: *** Generating dependent type windows.h for type HWND
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** tagging enum: VK_KHR_WIN32_SURFACE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_WIN32_SURFACE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR -> required = True
DIAG: *** tagging command: vkCreateWin32SurfaceKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkWin32SurfaceCreateInfoKHR
DIAG: *** tagging type: VkWin32SurfaceCreateInfoKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkWin32SurfaceCreateFlagsKHR
DIAG: *** tagging type: VkWin32SurfaceCreateFlagsKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> HINSTANCE
DIAG: *** tagging type: HINSTANCE -> required = True
DIAG: *** Generating dependent type windows.h for type HINSTANCE
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** markRequired: type requires dependent <type> HWND
DIAG: *** tagging type: HWND -> required = True
DIAG: *** Generating dependent type windows.h for type HWND
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkSurfaceKHR
DIAG: *** tagging type: VkSurfaceKHR -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceWin32PresentationSupportKHR -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_KHR_sampler_mirror_clamp_to_edge
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_EXT_debug_report
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** tagging type: VkDebugReportErrorEXT -> required = True
DIAG: *** tagging enum: VK_EXT_DEBUG_REPORT_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_EXT_DEBUG_REPORT_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT -> required = True
DIAG: *** tagging enum: VK_ERROR_VALIDATION_FAILED_EXT -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT -> required = True
DIAG: *** tagging command: vkCreateDebugReportCallbackEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugReportCallbackCreateInfoEXT
DIAG: *** tagging type: VkDebugReportCallbackCreateInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagsEXT -> required = True
DIAG: *** Generating dependent type VkDebugReportFlagBitsEXT for type VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagBitsEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkDebugReportCallbackEXT
DIAG: *** tagging type: PFN_vkDebugReportCallbackEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagsEXT -> required = True
DIAG: *** Generating dependent type VkDebugReportFlagBitsEXT for type VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagBitsEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugReportCallbackEXT
DIAG: *** tagging type: VkDebugReportCallbackEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging command: vkDestroyDebugReportCallbackEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugReportCallbackEXT
DIAG: *** tagging type: VkDebugReportCallbackEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkAllocationCallbacks
DIAG: *** tagging type: VkAllocationCallbacks -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkAllocationFunction
DIAG: *** tagging type: PFN_vkAllocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkReallocationFunction
DIAG: *** tagging type: PFN_vkReallocationFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkFreeFunction
DIAG: *** tagging type: PFN_vkFreeFunction -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** tagging type: PFN_vkInternalAllocationNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** markRequired: type requires dependent <type> PFN_vkInternalFreeNotification
DIAG: *** tagging type: PFN_vkInternalFreeNotification -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkInternalAllocationType
DIAG: *** tagging type: VkInternalAllocationType -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSystemAllocationScope
DIAG: *** tagging type: VkSystemAllocationScope -> required = True
DIAG: *** tagging command: vkDebugReportMessageEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkInstance
DIAG: *** tagging type: VkInstance -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagsEXT -> required = True
DIAG: *** Generating dependent type VkDebugReportFlagBitsEXT for type VkDebugReportFlagsEXT
DIAG: *** tagging type: VkDebugReportFlagBitsEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type int32_t
DIAG: *** tagging type: int32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type int32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_glsl_shader
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_NV_GLSL_SHADER_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_GLSL_SHADER_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_ERROR_INVALID_SHADER_NV -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_IMG_filter_cubic
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_IMG_FILTER_CUBIC_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_IMG_FILTER_CUBIC_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_FILTER_CUBIC_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_AMD_rasterization_order
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkRasterizationOrderAMD -> required = True
DIAG: *** tagging type: VkPipelineRasterizationStateRasterizationOrderAMD -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkRasterizationOrderAMD
DIAG: *** tagging type: VkRasterizationOrderAMD -> required = True
DIAG: *** tagging enum: VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_AMD_shader_trinary_minmax
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_AMD_shader_explicit_vertex_parameter
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_EXT_debug_marker
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkDebugMarkerObjectNameInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDebugMarkerObjectTagInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDebugMarkerMarkerInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_EXT_DEBUG_MARKER_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_EXT_DEBUG_MARKER_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT -> required = True
DIAG: *** tagging command: vkDebugMarkerSetObjectTagEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugMarkerObjectTagInfoEXT
DIAG: *** tagging type: VkDebugMarkerObjectTagInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> size_t
DIAG: *** tagging type: size_t -> required = True
DIAG: *** Generating dependent type vk_platform for type size_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkDebugMarkerSetObjectNameEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugMarkerObjectNameInfoEXT
DIAG: *** tagging type: VkDebugMarkerObjectNameInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** tagging type: VkDebugReportObjectTypeEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDebugMarkerBeginEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugMarkerMarkerInfoEXT
DIAG: *** tagging type: VkDebugMarkerMarkerInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDebugMarkerEndEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** tagging command: vkCmdDebugMarkerInsertEXT -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDebugMarkerMarkerInfoEXT
DIAG: *** tagging type: VkDebugMarkerMarkerInfoEXT -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> char
DIAG: *** tagging type: char -> required = True
DIAG: *** Generating dependent type vk_platform for type char
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> float
DIAG: *** tagging type: float -> required = True
DIAG: *** Generating dependent type vk_platform for type float
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_AMD_gcn_shader
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_AMD_GCN_SHADER_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_AMD_GCN_SHADER_EXTENSION_NAME -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_dedicated_allocation
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkDedicatedAllocationImageCreateInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDedicatedAllocationBufferCreateInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBool32
DIAG: *** tagging type: VkBool32 -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkDedicatedAllocationMemoryAllocateInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImage
DIAG: *** tagging type: VkImage -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** tagging enum: VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_AMD_draw_indirect_count
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_EXTENSION_NAME -> required = True
DIAG: *** tagging command: vkCmdDrawIndirectCountAMD -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging command: vkCmdDrawIndexedIndirectCountAMD -> required = True
DIAG: *** markRequired: command implicitly requires dependent type void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkCommandBuffer
DIAG: *** tagging type: VkCommandBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkBuffer
DIAG: *** tagging type: VkBuffer -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_IMG_format_pvrtc
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging enum: VK_IMG_FORMAT_PVRTC_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_IMG_FORMAT_PVRTC_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG -> required = True
DIAG: *** tagging enum: VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_external_memory_capabilities
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** tagging type: VkExternalMemoryFeatureFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryFeatureFlagBitsNV for type VkExternalMemoryFeatureFlagsNV
DIAG: *** tagging type: VkExternalMemoryFeatureFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkExternalMemoryFeatureFlagBitsNV -> required = True
DIAG: *** tagging type: VkExternalImageFormatPropertiesNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageFormatProperties
DIAG: *** tagging type: VkImageFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryFeatureFlagsNV
DIAG: *** tagging type: VkExternalMemoryFeatureFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryFeatureFlagBitsNV for type VkExternalMemoryFeatureFlagsNV
DIAG: *** tagging type: VkExternalMemoryFeatureFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME -> required = True
DIAG: *** tagging command: vkGetPhysicalDeviceExternalImageFormatPropertiesNV -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkPhysicalDevice
DIAG: *** tagging type: VkPhysicalDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkFormat
DIAG: *** tagging type: VkFormat -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageType
DIAG: *** tagging type: VkImageType -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageTiling
DIAG: *** tagging type: VkImageTiling -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlags -> required = True
DIAG: *** Generating dependent type VkImageUsageFlagBits for type VkImageUsageFlags
DIAG: *** tagging type: VkImageUsageFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlags -> required = True
DIAG: *** Generating dependent type VkImageCreateFlagBits for type VkImageCreateFlags
DIAG: *** tagging type: VkImageCreateFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExternalImageFormatPropertiesNV
DIAG: *** tagging type: VkExternalImageFormatPropertiesNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkImageFormatProperties
DIAG: *** tagging type: VkImageFormatProperties -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExtent3D
DIAG: *** tagging type: VkExtent3D -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlags -> required = True
DIAG: *** Generating dependent type VkSampleCountFlagBits for type VkSampleCountFlags
DIAG: *** tagging type: VkSampleCountFlagBits -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceSize
DIAG: *** tagging type: VkDeviceSize -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryFeatureFlagsNV
DIAG: *** tagging type: VkExternalMemoryFeatureFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryFeatureFlagBitsNV for type VkExternalMemoryFeatureFlagsNV
DIAG: *** tagging type: VkExternalMemoryFeatureFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_external_memory
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkExternalMemoryImageCreateInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging type: VkExportMemoryAllocateInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_external_memory_win32
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkImportMemoryWin32HandleInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> HANDLE
DIAG: *** tagging type: HANDLE -> required = True
DIAG: *** Generating dependent type windows.h for type HANDLE
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** tagging type: VkExportMemoryWin32HandleInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> SECURITY_ATTRIBUTES
DIAG: *** tagging type: SECURITY_ATTRIBUTES -> required = True
DIAG: *** Generating dependent type windows.h for type SECURITY_ATTRIBUTES
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** markRequired: type requires dependent <type> DWORD
DIAG: *** tagging type: DWORD -> required = True
DIAG: *** Generating dependent type windows.h for type DWORD
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV -> required = True
DIAG: *** tagging command: vkGetMemoryWin32HandleNV -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkResult
DIAG: *** tagging type: VkResult -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDevice
DIAG: *** tagging type: VkDevice -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_HANDLE
DIAG: *** tagging type: VK_DEFINE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: command implicitly requires dependent type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagsNV -> required = True
DIAG: *** Generating dependent type VkExternalMemoryHandleTypeFlagBitsNV for type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** tagging type: VkExternalMemoryHandleTypeFlagBitsNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkFlags
DIAG: *** tagging type: VkFlags -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: command implicitly requires dependent type HANDLE
DIAG: *** tagging type: HANDLE -> required = True
DIAG: *** Generating dependent type windows.h for type HANDLE
DIAG: *** tagging type: windows.h -> required = True
DIAG: *** PASS 1: Tagging required and removed features for VK_NV_win32_keyed_mutex
DIAG: *** markRequired (features = <too long to print>, required = True )
DIAG: *** tagging type: VkWin32KeyedMutexAcquireReleaseInfoNV -> required = True
DIAG: *** markRequired: type requires dependent <type> VkStructureType
DIAG: *** tagging type: VkStructureType -> required = True
DIAG: *** markRequired: type requires dependent <type> void
DIAG: *** tagging type: void -> required = True
DIAG: *** Generating dependent type vk_platform for type void
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> uint32_t
DIAG: *** tagging type: uint32_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint32_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** markRequired: type requires dependent <type> VkDeviceMemory
DIAG: *** tagging type: VkDeviceMemory -> required = True
DIAG: *** markRequired: type requires dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** tagging type: VK_DEFINE_NON_DISPATCHABLE_HANDLE -> required = True
DIAG: *** markRequired: type requires dependent <type> uint64_t
DIAG: *** tagging type: uint64_t -> required = True
DIAG: *** Generating dependent type vk_platform for type uint64_t
DIAG: *** tagging type: vk_platform -> required = True
DIAG: *** tagging enum: VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION -> required = True
DIAG: *** tagging enum: VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME -> required = True
DIAG: *** tagging enum: VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV -> required = True
DIAG: *** PASS 2: GENERATE INTERFACES FOR FEATURES ************************
DIAG: *** PASS 2: Generating interface for VK_VERSION_1_0
DIAG: *** Emitting type decl for vk_platform
DIAG: *** Generating required dependent <type> VK_MAKE_VERSION
DIAG: *** Emitting type decl for VK_MAKE_VERSION
DIAG: *** Emitting type decl for VK_API_VERSION
DIAG: *** Generating required dependent <type> VK_MAKE_VERSION
DIAG: *** Skipping type VK_MAKE_VERSION (already declared)
DIAG: *** Emitting type decl for VK_API_VERSION_1_0
DIAG: *** Emitting type decl for VK_VERSION_MAJOR
DIAG: *** Emitting type decl for VK_VERSION_MINOR
DIAG: *** Emitting type decl for VK_VERSION_PATCH
DIAG: *** Emitting type decl for VK_HEADER_VERSION
DIAG: *** Emitting type decl for VK_NULL_HANDLE
DIAG: *** Type VkPipelineCacheHeaderVersion is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPipelineCacheHeaderVersion
DIAG: *** Emitting enum decl for VK_LOD_CLAMP_NONE
DIAG: *** Emitting enum decl for VK_REMAINING_MIP_LEVELS
DIAG: *** Emitting enum decl for VK_REMAINING_ARRAY_LAYERS
DIAG: *** Emitting enum decl for VK_WHOLE_SIZE
DIAG: *** Emitting enum decl for VK_ATTACHMENT_UNUSED
DIAG: *** Emitting enum decl for VK_TRUE
DIAG: *** Emitting enum decl for VK_FALSE
DIAG: *** Emitting enum decl for VK_QUEUE_FAMILY_IGNORED
DIAG: *** Emitting enum decl for VK_SUBPASS_EXTERNAL
DIAG: *** Generating required parameter type VkResult
DIAG: *** Type VkResult is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkResult
DIAG: *** Generating required parameter type VkInstanceCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Type VkStructureType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkStructureType
DIAG: *** Generating required dependent <type> void
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for void
DIAG: *** Generating required dependent <type> VkInstanceCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for uint32_t
DIAG: *** Emitting type decl for VkFlags
DIAG: *** Emitting type decl for VkInstanceCreateFlags
DIAG: *** Generating required dependent <type> VkApplicationInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for char
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkApplicationInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Emitting type decl for VkInstanceCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> PFN_vkAllocationFunction
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for size_t
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> VkSystemAllocationScope
DIAG: *** Type VkSystemAllocationScope is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSystemAllocationScope
DIAG: *** Emitting type decl for PFN_vkAllocationFunction
DIAG: *** Generating required dependent <type> PFN_vkReallocationFunction
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> VkSystemAllocationScope
DIAG: *** Skipping type VkSystemAllocationScope (already declared)
DIAG: *** Emitting type decl for PFN_vkReallocationFunction
DIAG: *** Generating required dependent <type> PFN_vkFreeFunction
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for PFN_vkFreeFunction
DIAG: *** Generating required dependent <type> PFN_vkInternalAllocationNotification
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> VkInternalAllocationType
DIAG: *** Type VkInternalAllocationType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkInternalAllocationType
DIAG: *** Generating required dependent <type> VkSystemAllocationScope
DIAG: *** Skipping type VkSystemAllocationScope (already declared)
DIAG: *** Emitting type decl for PFN_vkInternalAllocationNotification
DIAG: *** Generating required dependent <type> PFN_vkInternalFreeNotification
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> VkInternalAllocationType
DIAG: *** Skipping type VkInternalAllocationType (already declared)
DIAG: *** Generating required dependent <type> VkSystemAllocationScope
DIAG: *** Skipping type VkSystemAllocationScope (already declared)
DIAG: *** Emitting type decl for PFN_vkInternalFreeNotification
DIAG: *** Emitting type decl for VkAllocationCallbacks
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Generating required dependent <type> VK_DEFINE_HANDLE
DIAG: *** Emitting type decl for VK_DEFINE_HANDLE
DIAG: *** Emitting type decl for VkInstance
DIAG: *** Emitting command decl for vkCreateInstance
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     const VkInstanceCreateInfo*                 
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pInstance to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkInstance*                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyInstance
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Generating required dependent <type> VK_DEFINE_HANDLE
DIAG: *** Skipping type VK_DEFINE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkPhysicalDevice
DIAG: *** Emitting command decl for vkEnumeratePhysicalDevices
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pPhysicalDeviceCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pPhysicalDevices to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkPhysicalDevice*                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkPhysicalDeviceFeatures
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkBool32
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkPhysicalDeviceFeatures
DIAG: *** Emitting command decl for vkGetPhysicalDeviceFeatures
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pFeatures to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     VkPhysicalDeviceFeatures*                   
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkFormat
DIAG: *** Type VkFormat is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkFormat
DIAG: *** Generating required parameter type VkFormatProperties
DIAG: *** Generating required dependent <type> VkFormatFeatureFlags
DIAG: *** Generating required dependent type VkFormatFeatureFlagBits
DIAG: *** Type VkFormatFeatureFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkFormatFeatureFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkFormatFeatureFlags
DIAG: *** Generating required dependent <type> VkFormatFeatureFlags
DIAG: *** Skipping type VkFormatFeatureFlags (already declared)
DIAG: *** Generating required dependent <type> VkFormatFeatureFlags
DIAG: *** Skipping type VkFormatFeatureFlags (already declared)
DIAG: *** Emitting type decl for VkFormatProperties
DIAG: *** Emitting command decl for vkGetPhysicalDeviceFormatProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter format to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFormat                                    
DIAG: Aligning parameter pFormatProperties to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     VkFormatProperties*                         
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required parameter type VkImageType
DIAG: *** Type VkImageType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageType
DIAG: *** Generating required parameter type VkImageTiling
DIAG: *** Type VkImageTiling is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageTiling
DIAG: *** Generating required parameter type VkImageUsageFlags
DIAG: *** Generating required dependent type VkImageUsageFlagBits
DIAG: *** Type VkImageUsageFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageUsageFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkImageUsageFlags
DIAG: *** Generating required parameter type VkImageCreateFlags
DIAG: *** Generating required dependent type VkImageCreateFlagBits
DIAG: *** Type VkImageCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkImageCreateFlags
DIAG: *** Generating required parameter type VkImageFormatProperties
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkExtent3D
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Generating required dependent type VkSampleCountFlagBits
DIAG: *** Type VkSampleCountFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSampleCountFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSampleCountFlags
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for uint64_t
DIAG: *** Emitting type decl for VkDeviceSize
DIAG: *** Emitting type decl for VkImageFormatProperties
DIAG: *** Emitting command decl for vkGetPhysicalDeviceImageFormatProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter format to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFormat                                    
DIAG: Aligning parameter type to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkImageType                                 
DIAG: Aligning parameter tiling to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageTiling                               
DIAG: Aligning parameter usage to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkImageUsageFlags                           
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkImageCreateFlags                          
DIAG: Aligning parameter pImageFormatProperties to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     VkImageFormatProperties*                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkPhysicalDeviceProperties
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPhysicalDeviceType
DIAG: *** Type VkPhysicalDeviceType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPhysicalDeviceType
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint8_t
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for uint8_t
DIAG: *** Generating required dependent <type> VkPhysicalDeviceLimits
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for float
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Generating required dependent type vk_platform
DIAG: *** Skipping type vk_platform (already declared)
DIAG: *** Emitting type decl for int32_t
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlags
DIAG: *** Skipping type VkSampleCountFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkPhysicalDeviceLimits
DIAG: *** Generating required dependent <type> VkPhysicalDeviceSparseProperties
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkPhysicalDeviceSparseProperties
DIAG: *** Generating required dependent <enum> VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
DIAG: *** Emitting enum decl for VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
DIAG: *** Generating required dependent <enum> VK_UUID_SIZE
DIAG: *** Emitting enum decl for VK_UUID_SIZE
DIAG: *** Emitting type decl for VkPhysicalDeviceProperties
DIAG: *** Emitting command decl for vkGetPhysicalDeviceProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     VkPhysicalDeviceProperties*                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkQueueFamilyProperties
DIAG: *** Generating required dependent <type> VkQueueFlags
DIAG: *** Generating required dependent type VkQueueFlagBits
DIAG: *** Type VkQueueFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkQueueFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkQueueFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Emitting type decl for VkQueueFamilyProperties
DIAG: *** Emitting command decl for vkGetPhysicalDeviceQueueFamilyProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pQueueFamilyPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pQueueFamilyProperties to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     VkQueueFamilyProperties*                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkPhysicalDeviceMemoryProperties
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkMemoryType
DIAG: *** Generating required dependent <type> VkMemoryPropertyFlags
DIAG: *** Generating required dependent type VkMemoryPropertyFlagBits
DIAG: *** Type VkMemoryPropertyFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkMemoryPropertyFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkMemoryPropertyFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkMemoryType
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkMemoryHeap
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkMemoryHeapFlags
DIAG: *** Generating required dependent type VkMemoryHeapFlagBits
DIAG: *** Type VkMemoryHeapFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkMemoryHeapFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkMemoryHeapFlags
DIAG: *** Emitting type decl for VkMemoryHeap
DIAG: *** Generating required dependent <enum> VK_MAX_MEMORY_TYPES
DIAG: *** Emitting enum decl for VK_MAX_MEMORY_TYPES
DIAG: *** Generating required dependent <enum> VK_MAX_MEMORY_HEAPS
DIAG: *** Emitting enum decl for VK_MAX_MEMORY_HEAPS
DIAG: *** Emitting type decl for VkPhysicalDeviceMemoryProperties
DIAG: *** Emitting command decl for vkGetPhysicalDeviceMemoryProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pMemoryProperties to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     VkPhysicalDeviceMemoryProperties*           
DIAG: *** Generating required parameter type PFN_vkVoidFunction
DIAG: *** Emitting type decl for PFN_vkVoidFunction
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Emitting command decl for vkGetInstanceProcAddr
DIAG: *** Generating required parameter type PFN_vkVoidFunction
DIAG: *** Skipping type PFN_vkVoidFunction (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Generating required dependent <type> VK_DEFINE_HANDLE
DIAG: *** Skipping type VK_DEFINE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDevice
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Emitting command decl for vkGetDeviceProcAddr
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDeviceCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDeviceCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceQueueCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDeviceQueueCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDeviceQueueCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkDeviceQueueCreateInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> VkPhysicalDeviceFeatures
DIAG: *** Skipping type VkPhysicalDeviceFeatures (already declared)
DIAG: *** Emitting type decl for VkDeviceCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Emitting command decl for vkCreateDevice
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     const VkDeviceCreateInfo*                   
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pDevice to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     VkDevice*                                   
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyDevice
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkExtensionProperties
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** Emitting enum decl for VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** Emitting type decl for VkExtensionProperties
DIAG: *** Emitting command decl for vkEnumerateInstanceExtensionProperties
DIAG: Aligning parameter pLayerName to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     const char*                                 
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     VkExtensionProperties*                      
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkExtensionProperties
DIAG: *** Skipping type VkExtensionProperties (already declared)
DIAG: *** Emitting command decl for vkEnumerateDeviceExtensionProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pLayerName to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     const char*                                 
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     VkExtensionProperties*                      
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkLayerProperties
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <enum> VK_MAX_EXTENSION_NAME_SIZE
DIAG: *** Skipping enum VK_MAX_EXTENSION_NAME_SIZE (already declared)
DIAG: *** Generating required dependent <enum> VK_MAX_DESCRIPTION_SIZE
DIAG: *** Emitting enum decl for VK_MAX_DESCRIPTION_SIZE
DIAG: *** Emitting type decl for VkLayerProperties
DIAG: *** Emitting command decl for vkEnumerateInstanceLayerProperties
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkLayerProperties
DIAG: *** Skipping type VkLayerProperties (already declared)
DIAG: *** Emitting command decl for vkEnumerateDeviceLayerProperties
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkQueue
DIAG: *** Generating required dependent <type> VK_DEFINE_HANDLE
DIAG: *** Skipping type VK_DEFINE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkQueue
DIAG: *** Emitting command decl for vkGetDeviceQueue
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter queueIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pQueue to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkQueue*                                    
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkQueue
DIAG: *** Skipping type VkQueue (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSubmitInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSemaphore
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Emitting type decl for VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Emitting type decl for VkSemaphore
DIAG: *** Generating required dependent <type> VkPipelineStageFlags
DIAG: *** Generating required dependent type VkPipelineStageFlagBits
DIAG: *** Type VkPipelineStageFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPipelineStageFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineStageFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkCommandBuffer
DIAG: *** Generating required dependent <type> VK_DEFINE_HANDLE
DIAG: *** Skipping type VK_DEFINE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkCommandBuffer
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Emitting type decl for VkSubmitInfo
DIAG: *** Generating required parameter type VkFence
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkFence
DIAG: *** Emitting command decl for vkQueueSubmit
DIAG: Aligning parameter queue to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkQueue                                     
DIAG: Aligning parameter submitCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pSubmits to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     const VkSubmitInfo*                         
DIAG: Aligning parameter fence to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkFence                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkQueue
DIAG: *** Skipping type VkQueue (already declared)
DIAG: *** Emitting command decl for vkQueueWaitIdle
DIAG: Aligning parameter queue to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkQueue                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Emitting command decl for vkDeviceWaitIdle
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkMemoryAllocateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkMemoryAllocateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDeviceMemory
DIAG: *** Emitting command decl for vkAllocateMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pAllocateInfo to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     const VkMemoryAllocateInfo*                 
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pMemory to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkDeviceMemory*                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkFreeMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkMemoryMapFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkMemoryMapFlags
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting command decl for vkMapMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter size to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkMemoryMapFlags                            
DIAG: Aligning parameter ppData to column 48
DIAG: Adjust length of parameter decl from 10 to 48 :     void**                                      
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Emitting command decl for vkUnmapMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkMappedMemoryRange
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkMappedMemoryRange
DIAG: *** Emitting command decl for vkFlushMappedMemoryRanges
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memoryRangeCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pMemoryRanges to column 48
DIAG: Adjust length of parameter decl from 30 to 48 :     const VkMappedMemoryRange*                  
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkMappedMemoryRange
DIAG: *** Skipping type VkMappedMemoryRange (already declared)
DIAG: *** Emitting command decl for vkInvalidateMappedMemoryRanges
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memoryRangeCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pMemoryRanges to column 48
DIAG: Adjust length of parameter decl from 30 to 48 :     const VkMappedMemoryRange*                  
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting command decl for vkGetDeviceMemoryCommitment
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter pCommittedMemoryInBytes to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkDeviceSize*                               
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkBuffer
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting command decl for vkBindBufferMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter memoryOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkImage
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting command decl for vkBindImageMemory
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter memoryOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkMemoryRequirements
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkMemoryRequirements
DIAG: *** Emitting command decl for vkGetBufferMemoryRequirements
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter pMemoryRequirements to column 48
DIAG: Adjust length of parameter decl from 25 to 48 :     VkMemoryRequirements*                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkMemoryRequirements
DIAG: *** Skipping type VkMemoryRequirements (already declared)
DIAG: *** Emitting command decl for vkGetImageMemoryRequirements
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter pMemoryRequirements to column 48
DIAG: Adjust length of parameter decl from 25 to 48 :     VkMemoryRequirements*                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSparseImageMemoryRequirements
DIAG: *** Generating required dependent <type> VkSparseImageFormatProperties
DIAG: *** Generating required dependent <type> VkImageAspectFlags
DIAG: *** Generating required dependent type VkImageAspectFlagBits
DIAG: *** Type VkImageAspectFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageAspectFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkImageAspectFlags
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Generating required dependent <type> VkSparseImageFormatFlags
DIAG: *** Generating required dependent type VkSparseImageFormatFlagBits
DIAG: *** Type VkSparseImageFormatFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSparseImageFormatFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSparseImageFormatFlags
DIAG: *** Emitting type decl for VkSparseImageFormatProperties
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkSparseImageMemoryRequirements
DIAG: *** Emitting command decl for vkGetImageSparseMemoryRequirements
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter pSparseMemoryRequirementCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pSparseMemoryRequirements to column 48
DIAG: Adjust length of parameter decl from 36 to 48 :     VkSparseImageMemoryRequirements*            
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required parameter type VkImageType
DIAG: *** Skipping type VkImageType (already declared)
DIAG: *** Generating required parameter type VkSampleCountFlagBits
DIAG: *** Skipping type VkSampleCountFlagBits (already declared)
DIAG: *** Generating required parameter type VkImageUsageFlags
DIAG: *** Skipping type VkImageUsageFlags (already declared)
DIAG: *** Generating required parameter type VkImageTiling
DIAG: *** Skipping type VkImageTiling (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSparseImageFormatProperties
DIAG: *** Skipping type VkSparseImageFormatProperties (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceSparseImageFormatProperties
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter format to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFormat                                    
DIAG: Aligning parameter type to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkImageType                                 
DIAG: Aligning parameter samples to column 48
DIAG: Adjust length of parameter decl from 25 to 48 :     VkSampleCountFlagBits                       
DIAG: Aligning parameter usage to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkImageUsageFlags                           
DIAG: Aligning parameter tiling to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageTiling                               
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     VkSparseImageFormatProperties*              
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkQueue
DIAG: *** Skipping type VkQueue (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBindSparseInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseBufferMemoryBindInfo
DIAG: *** Generating required dependent <type> VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseMemoryBind
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkSparseMemoryBindFlags
DIAG: *** Generating required dependent type VkSparseMemoryBindFlagBits
DIAG: *** Type VkSparseMemoryBindFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSparseMemoryBindFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSparseMemoryBindFlags
DIAG: *** Emitting type decl for VkSparseMemoryBind
DIAG: *** Emitting type decl for VkSparseBufferMemoryBindInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseImageOpaqueMemoryBindInfo
DIAG: *** Generating required dependent <type> VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseMemoryBind
DIAG: *** Skipping type VkSparseMemoryBind (already declared)
DIAG: *** Emitting type decl for VkSparseImageOpaqueMemoryBindInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseImageMemoryBindInfo
DIAG: *** Generating required dependent <type> VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSparseImageMemoryBind
DIAG: *** Generating required dependent <type> VkImageSubresource
DIAG: *** Generating required dependent <type> VkImageAspectFlags
DIAG: *** Skipping type VkImageAspectFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkImageSubresource
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Emitting type decl for VkOffset3D
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Generating required dependent <type> VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkSparseMemoryBindFlags
DIAG: *** Skipping type VkSparseMemoryBindFlags (already declared)
DIAG: *** Emitting type decl for VkSparseImageMemoryBind
DIAG: *** Emitting type decl for VkSparseImageMemoryBindInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Emitting type decl for VkBindSparseInfo
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Emitting command decl for vkQueueBindSparse
DIAG: Aligning parameter queue to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkQueue                                     
DIAG: Aligning parameter bindInfoCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pBindInfo to column 48
DIAG: Adjust length of parameter decl from 27 to 48 :     const VkBindSparseInfo*                     
DIAG: Aligning parameter fence to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkFence                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkFenceCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkFenceCreateFlags
DIAG: *** Generating required dependent type VkFenceCreateFlagBits
DIAG: *** Type VkFenceCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkFenceCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkFenceCreateFlags
DIAG: *** Emitting type decl for VkFenceCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Emitting command decl for vkCreateFence
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkFenceCreateInfo*                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pFence to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFence*                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyFence
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter fence to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkFence                                     
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Emitting command decl for vkResetFences
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter fenceCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pFences to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     const VkFence*                              
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Emitting command decl for vkGetFenceStatus
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter fence to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkFence                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Emitting command decl for vkWaitForFences
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter fenceCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pFences to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     const VkFence*                              
DIAG: Aligning parameter waitAll to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBool32                                    
DIAG: Aligning parameter timeout to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint64_t                                    
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSemaphoreCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkSemaphoreCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSemaphoreCreateFlags
DIAG: *** Emitting type decl for VkSemaphoreCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Emitting command decl for vkCreateSemaphore
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkSemaphoreCreateInfo*                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSemaphore to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSemaphore*                                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroySemaphore
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter semaphore to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkSemaphore                                 
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkEventCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkEventCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkEventCreateFlags
DIAG: *** Emitting type decl for VkEventCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkEvent
DIAG: *** Emitting command decl for vkCreateEvent
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkEventCreateInfo*                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pEvent to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkEvent*                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyEvent
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Emitting command decl for vkGetEventStatus
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Emitting command decl for vkSetEvent
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Emitting command decl for vkResetEvent
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkQueryPoolCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkQueryPoolCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkQueryPoolCreateFlags
DIAG: *** Generating required dependent <type> VkQueryType
DIAG: *** Type VkQueryType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkQueryType
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkQueryPipelineStatisticFlags
DIAG: *** Generating required dependent type VkQueryPipelineStatisticFlagBits
DIAG: *** Type VkQueryPipelineStatisticFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkQueryPipelineStatisticFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkQueryPipelineStatisticFlags
DIAG: *** Emitting type decl for VkQueryPoolCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkQueryPool
DIAG: *** Emitting command decl for vkCreateQueryPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkQueryPoolCreateInfo*                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pQueryPool to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkQueryPool*                                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyQueryPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkQueryResultFlags
DIAG: *** Generating required dependent type VkQueryResultFlagBits
DIAG: *** Type VkQueryResultFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkQueryResultFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkQueryResultFlags
DIAG: *** Emitting command decl for vkGetQueryPoolResults
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter firstQuery to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter queryCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter dataSize to column 48
DIAG: Adjust length of parameter decl from 10 to 48 :     size_t                                      
DIAG: Aligning parameter pData to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     void*                                       
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkQueryResultFlags                          
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBufferCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkBufferCreateFlags
DIAG: *** Generating required dependent type VkBufferCreateFlagBits
DIAG: *** Type VkBufferCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkBufferCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkBufferCreateFlags
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkBufferUsageFlags
DIAG: *** Generating required dependent type VkBufferUsageFlagBits
DIAG: *** Type VkBufferUsageFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkBufferUsageFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkBufferUsageFlags
DIAG: *** Generating required dependent <type> VkSharingMode
DIAG: *** Type VkSharingMode is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSharingMode
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkBufferCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Emitting command decl for vkCreateBuffer
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     const VkBufferCreateInfo*                   
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pBuffer to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     VkBuffer*                                   
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyBuffer
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBufferViewCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkBufferViewCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkBufferViewCreateFlags
DIAG: *** Generating required dependent <type> VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkBufferViewCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkBufferView
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkBufferView
DIAG: *** Emitting command decl for vkCreateBufferView
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 33 to 48 :     const VkBufferViewCreateInfo*               
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pView to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkBufferView*                               
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkBufferView
DIAG: *** Skipping type VkBufferView (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyBufferView
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter bufferView to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkBufferView                                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImageCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkImageCreateFlags
DIAG: *** Skipping type VkImageCreateFlags (already declared)
DIAG: *** Generating required dependent <type> VkImageType
DIAG: *** Skipping type VkImageType (already declared)
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlagBits
DIAG: *** Skipping type VkSampleCountFlagBits (already declared)
DIAG: *** Generating required dependent <type> VkImageTiling
DIAG: *** Skipping type VkImageTiling (already declared)
DIAG: *** Generating required dependent <type> VkImageUsageFlags
DIAG: *** Skipping type VkImageUsageFlags (already declared)
DIAG: *** Generating required dependent <type> VkSharingMode
DIAG: *** Skipping type VkSharingMode (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Type VkImageLayout is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageLayout
DIAG: *** Emitting type decl for VkImageCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Emitting command decl for vkCreateImage
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkImageCreateInfo*                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pImage to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkImage*                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyImage
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageSubresource
DIAG: *** Skipping type VkImageSubresource (already declared)
DIAG: *** Generating required parameter type VkSubresourceLayout
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkSubresourceLayout
DIAG: *** Emitting command decl for vkGetImageSubresourceLayout
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter pSubresource to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     const VkImageSubresource*                   
DIAG: Aligning parameter pLayout to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkSubresourceLayout*                        
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImageViewCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkImageViewCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkImageViewCreateFlags
DIAG: *** Generating required dependent <type> VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required dependent <type> VkImageViewType
DIAG: *** Type VkImageViewType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkImageViewType
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkComponentMapping
DIAG: *** Generating required dependent <type> VkComponentSwizzle
DIAG: *** Type VkComponentSwizzle is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkComponentSwizzle
DIAG: *** Generating required dependent <type> VkComponentSwizzle
DIAG: *** Skipping type VkComponentSwizzle (already declared)
DIAG: *** Generating required dependent <type> VkComponentSwizzle
DIAG: *** Skipping type VkComponentSwizzle (already declared)
DIAG: *** Generating required dependent <type> VkComponentSwizzle
DIAG: *** Skipping type VkComponentSwizzle (already declared)
DIAG: *** Emitting type decl for VkComponentMapping
DIAG: *** Generating required dependent <type> VkImageSubresourceRange
DIAG: *** Generating required dependent <type> VkImageAspectFlags
DIAG: *** Skipping type VkImageAspectFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkImageSubresourceRange
DIAG: *** Emitting type decl for VkImageViewCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkImageView
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkImageView
DIAG: *** Emitting command decl for vkCreateImageView
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkImageViewCreateInfo*                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pView to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkImageView*                                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkImageView
DIAG: *** Skipping type VkImageView (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyImageView
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter imageView to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkImageView                                 
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkShaderModuleCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkShaderModuleCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkShaderModuleCreateFlags
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkShaderModuleCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkShaderModule
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkShaderModule
DIAG: *** Emitting command decl for vkCreateShaderModule
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     const VkShaderModuleCreateInfo*             
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pShaderModule to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkShaderModule*                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkShaderModule
DIAG: *** Skipping type VkShaderModule (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyShaderModule
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter shaderModule to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkShaderModule                              
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCacheCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineCacheCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineCacheCreateFlags
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for VkPipelineCacheCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkPipelineCache
DIAG: *** Emitting command decl for vkCreatePipelineCache
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 36 to 48 :     const VkPipelineCacheCreateInfo*            
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pPipelineCache to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPipelineCache*                            
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyPipelineCache
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipelineCache to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkPipelineCache                             
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Generating required parameter type size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting command decl for vkGetPipelineCacheData
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipelineCache to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkPipelineCache                             
DIAG: Aligning parameter pDataSize to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     size_t*                                     
DIAG: Aligning parameter pData to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     void*                                       
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Emitting command decl for vkMergePipelineCaches
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter dstCache to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkPipelineCache                             
DIAG: Aligning parameter srcCacheCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pSrcCaches to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkPipelineCache*                      
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkGraphicsPipelineCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineCreateFlags
DIAG: *** Generating required dependent type VkPipelineCreateFlagBits
DIAG: *** Type VkPipelineCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPipelineCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPipelineShaderStageCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineShaderStageCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineShaderStageCreateFlags
DIAG: *** Generating required dependent <type> VkShaderStageFlagBits
DIAG: *** Type VkShaderStageFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkShaderStageFlagBits
DIAG: *** Generating required dependent <type> VkShaderModule
DIAG: *** Skipping type VkShaderModule (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> VkSpecializationInfo
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSpecializationMapEntry
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Emitting type decl for VkSpecializationMapEntry
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for VkSpecializationInfo
DIAG: *** Emitting type decl for VkPipelineShaderStageCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineVertexInputStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineVertexInputStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineVertexInputStateCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkVertexInputBindingDescription
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkVertexInputRate
DIAG: *** Type VkVertexInputRate is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkVertexInputRate
DIAG: *** Emitting type decl for VkVertexInputBindingDescription
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkVertexInputAttributeDescription
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkVertexInputAttributeDescription
DIAG: *** Emitting type decl for VkPipelineVertexInputStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineInputAssemblyStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineInputAssemblyStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineInputAssemblyStateCreateFlags
DIAG: *** Generating required dependent <type> VkPrimitiveTopology
DIAG: *** Type VkPrimitiveTopology is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPrimitiveTopology
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkPipelineInputAssemblyStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineTessellationStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineTessellationStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineTessellationStateCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkPipelineTessellationStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineViewportStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineViewportStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineViewportStateCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkViewport
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkViewport
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkRect2D
DIAG: *** Generating required dependent <type> VkOffset2D
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Emitting type decl for VkOffset2D
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkExtent2D
DIAG: *** Emitting type decl for VkRect2D
DIAG: *** Emitting type decl for VkPipelineViewportStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineRasterizationStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineRasterizationStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineRasterizationStateCreateFlags
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkPolygonMode
DIAG: *** Type VkPolygonMode is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPolygonMode
DIAG: *** Generating required dependent <type> VkCullModeFlags
DIAG: *** Generating required dependent type VkCullModeFlagBits
DIAG: *** Type VkCullModeFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCullModeFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCullModeFlags
DIAG: *** Generating required dependent <type> VkFrontFace
DIAG: *** Type VkFrontFace is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkFrontFace
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkPipelineRasterizationStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineMultisampleStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineMultisampleStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineMultisampleStateCreateFlags
DIAG: *** Generating required dependent <type> VkSampleCountFlagBits
DIAG: *** Skipping type VkSampleCountFlagBits (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkSampleMask
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkSampleMask
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkPipelineMultisampleStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineDepthStencilStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineDepthStencilStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineDepthStencilStateCreateFlags
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkCompareOp
DIAG: *** Type VkCompareOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCompareOp
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkStencilOpState
DIAG: *** Generating required dependent <type> VkStencilOp
DIAG: *** Type VkStencilOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkStencilOp
DIAG: *** Generating required dependent <type> VkStencilOp
DIAG: *** Skipping type VkStencilOp (already declared)
DIAG: *** Generating required dependent <type> VkStencilOp
DIAG: *** Skipping type VkStencilOp (already declared)
DIAG: *** Generating required dependent <type> VkCompareOp
DIAG: *** Skipping type VkCompareOp (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkStencilOpState
DIAG: *** Generating required dependent <type> VkStencilOpState
DIAG: *** Skipping type VkStencilOpState (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkPipelineDepthStencilStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineColorBlendStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineColorBlendStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineColorBlendStateCreateFlags
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkLogicOp
DIAG: *** Type VkLogicOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkLogicOp
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPipelineColorBlendAttachmentState
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBlendFactor
DIAG: *** Type VkBlendFactor is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkBlendFactor
DIAG: *** Generating required dependent <type> VkBlendFactor
DIAG: *** Skipping type VkBlendFactor (already declared)
DIAG: *** Generating required dependent <type> VkBlendOp
DIAG: *** Type VkBlendOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkBlendOp
DIAG: *** Generating required dependent <type> VkBlendFactor
DIAG: *** Skipping type VkBlendFactor (already declared)
DIAG: *** Generating required dependent <type> VkBlendFactor
DIAG: *** Skipping type VkBlendFactor (already declared)
DIAG: *** Generating required dependent <type> VkBlendOp
DIAG: *** Skipping type VkBlendOp (already declared)
DIAG: *** Generating required dependent <type> VkColorComponentFlags
DIAG: *** Generating required dependent type VkColorComponentFlagBits
DIAG: *** Type VkColorComponentFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkColorComponentFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkColorComponentFlags
DIAG: *** Emitting type decl for VkPipelineColorBlendAttachmentState
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkPipelineColorBlendStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineDynamicStateCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineDynamicStateCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineDynamicStateCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDynamicState
DIAG: *** Type VkDynamicState is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDynamicState
DIAG: *** Emitting type decl for VkPipelineDynamicStateCreateInfo
DIAG: *** Generating required dependent <type> VkPipelineLayout
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkPipelineLayout
DIAG: *** Generating required dependent <type> VkRenderPass
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkRenderPass
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPipeline
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkPipeline
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Emitting type decl for VkGraphicsPipelineCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkPipeline
DIAG: *** Skipping type VkPipeline (already declared)
DIAG: *** Emitting command decl for vkCreateGraphicsPipelines
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipelineCache to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkPipelineCache                             
DIAG: Aligning parameter createInfoCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCreateInfos to column 48
DIAG: Adjust length of parameter decl from 39 to 48 :     const VkGraphicsPipelineCreateInfo*         
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pPipelines to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkPipeline*                                 
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineCache
DIAG: *** Skipping type VkPipelineCache (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkComputePipelineCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineCreateFlags
DIAG: *** Skipping type VkPipelineCreateFlags (already declared)
DIAG: *** Generating required dependent <type> VkPipelineShaderStageCreateInfo
DIAG: *** Skipping type VkPipelineShaderStageCreateInfo (already declared)
DIAG: *** Generating required dependent <type> VkPipelineLayout
DIAG: *** Skipping type VkPipelineLayout (already declared)
DIAG: *** Generating required dependent <type> VkPipeline
DIAG: *** Skipping type VkPipeline (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Emitting type decl for VkComputePipelineCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkPipeline
DIAG: *** Skipping type VkPipeline (already declared)
DIAG: *** Emitting command decl for vkCreateComputePipelines
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipelineCache to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkPipelineCache                             
DIAG: Aligning parameter createInfoCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCreateInfos to column 48
DIAG: Adjust length of parameter decl from 38 to 48 :     const VkComputePipelineCreateInfo*          
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pPipelines to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkPipeline*                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipeline
DIAG: *** Skipping type VkPipeline (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyPipeline
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipeline to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkPipeline                                  
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineLayoutCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkPipelineLayoutCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkPipelineLayoutCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSetLayout
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDescriptorSetLayout
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPushConstantRange
DIAG: *** Generating required dependent <type> VkShaderStageFlags
DIAG: *** Generating required dependent type VkShaderStageFlagBits
DIAG: *** Skipping type VkShaderStageFlagBits (already declared)
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkShaderStageFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkPushConstantRange
DIAG: *** Emitting type decl for VkPipelineLayoutCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkPipelineLayout
DIAG: *** Skipping type VkPipelineLayout (already declared)
DIAG: *** Emitting command decl for vkCreatePipelineLayout
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     const VkPipelineLayoutCreateInfo*           
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pPipelineLayout to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkPipelineLayout*                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkPipelineLayout
DIAG: *** Skipping type VkPipelineLayout (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyPipelineLayout
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pipelineLayout to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPipelineLayout                            
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSamplerCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkSamplerCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSamplerCreateFlags
DIAG: *** Generating required dependent <type> VkFilter
DIAG: *** Type VkFilter is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkFilter
DIAG: *** Generating required dependent <type> VkFilter
DIAG: *** Skipping type VkFilter (already declared)
DIAG: *** Generating required dependent <type> VkSamplerMipmapMode
DIAG: *** Type VkSamplerMipmapMode is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSamplerMipmapMode
DIAG: *** Generating required dependent <type> VkSamplerAddressMode
DIAG: *** Type VkSamplerAddressMode is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSamplerAddressMode
DIAG: *** Generating required dependent <type> VkSamplerAddressMode
DIAG: *** Skipping type VkSamplerAddressMode (already declared)
DIAG: *** Generating required dependent <type> VkSamplerAddressMode
DIAG: *** Skipping type VkSamplerAddressMode (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkCompareOp
DIAG: *** Skipping type VkCompareOp (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkBorderColor
DIAG: *** Type VkBorderColor is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkBorderColor
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkSamplerCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSampler
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkSampler
DIAG: *** Emitting command decl for vkCreateSampler
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 30 to 48 :     const VkSamplerCreateInfo*                  
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSampler to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkSampler*                                  
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSampler
DIAG: *** Skipping type VkSampler (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroySampler
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter sampler to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     VkSampler                                   
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorSetLayoutCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSetLayoutCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDescriptorSetLayoutCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSetLayoutBinding
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorType
DIAG: *** Type VkDescriptorType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDescriptorType
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkShaderStageFlags
DIAG: *** Skipping type VkShaderStageFlags (already declared)
DIAG: *** Generating required dependent <type> VkSampler
DIAG: *** Skipping type VkSampler (already declared)
DIAG: *** Emitting type decl for VkDescriptorSetLayoutBinding
DIAG: *** Emitting type decl for VkDescriptorSetLayoutCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDescriptorSetLayout
DIAG: *** Skipping type VkDescriptorSetLayout (already declared)
DIAG: *** Emitting command decl for vkCreateDescriptorSetLayout
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 42 to 48 :     const VkDescriptorSetLayoutCreateInfo*      
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSetLayout to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     VkDescriptorSetLayout*                      
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorSetLayout
DIAG: *** Skipping type VkDescriptorSetLayout (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyDescriptorSetLayout
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter descriptorSetLayout to column 48
DIAG: Adjust length of parameter decl from 25 to 48 :     VkDescriptorSetLayout                       
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorPoolCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorPoolCreateFlags
DIAG: *** Generating required dependent type VkDescriptorPoolCreateFlagBits
DIAG: *** Type VkDescriptorPoolCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDescriptorPoolCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDescriptorPoolCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorPoolSize
DIAG: *** Generating required dependent <type> VkDescriptorType
DIAG: *** Skipping type VkDescriptorType (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDescriptorPoolSize
DIAG: *** Emitting type decl for VkDescriptorPoolCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDescriptorPool
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDescriptorPool
DIAG: *** Emitting command decl for vkCreateDescriptorPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     const VkDescriptorPoolCreateInfo*           
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pDescriptorPool to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkDescriptorPool*                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorPool
DIAG: *** Skipping type VkDescriptorPool (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyDescriptorPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter descriptorPool to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkDescriptorPool                            
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorPool
DIAG: *** Skipping type VkDescriptorPool (already declared)
DIAG: *** Generating required parameter type VkDescriptorPoolResetFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDescriptorPoolResetFlags
DIAG: *** Emitting command decl for vkResetDescriptorPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter descriptorPool to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkDescriptorPool                            
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 30 to 48 :     VkDescriptorPoolResetFlags                  
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorSetAllocateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorPool
DIAG: *** Skipping type VkDescriptorPool (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSetLayout
DIAG: *** Skipping type VkDescriptorSetLayout (already declared)
DIAG: *** Emitting type decl for VkDescriptorSetAllocateInfo
DIAG: *** Generating required parameter type VkDescriptorSet
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDescriptorSet
DIAG: *** Emitting command decl for vkAllocateDescriptorSets
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pAllocateInfo to column 48
DIAG: Adjust length of parameter decl from 38 to 48 :     const VkDescriptorSetAllocateInfo*          
DIAG: Aligning parameter pDescriptorSets to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkDescriptorSet*                            
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDescriptorPool
DIAG: *** Skipping type VkDescriptorPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDescriptorSet
DIAG: *** Skipping type VkDescriptorSet (already declared)
DIAG: *** Emitting command decl for vkFreeDescriptorSets
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter descriptorPool to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkDescriptorPool                            
DIAG: Aligning parameter descriptorSetCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDescriptorSets to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkDescriptorSet*                      
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkWriteDescriptorSet
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSet
DIAG: *** Skipping type VkDescriptorSet (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorType
DIAG: *** Skipping type VkDescriptorType (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorImageInfo
DIAG: *** Generating required dependent <type> VkSampler
DIAG: *** Skipping type VkSampler (already declared)
DIAG: *** Generating required dependent <type> VkImageView
DIAG: *** Skipping type VkImageView (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Emitting type decl for VkDescriptorImageInfo
DIAG: *** Generating required dependent <type> VkDescriptorBufferInfo
DIAG: *** Generating required dependent <type> VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkDescriptorBufferInfo
DIAG: *** Generating required dependent <type> VkBufferView
DIAG: *** Skipping type VkBufferView (already declared)
DIAG: *** Emitting type decl for VkWriteDescriptorSet
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkCopyDescriptorSet
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSet
DIAG: *** Skipping type VkDescriptorSet (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDescriptorSet
DIAG: *** Skipping type VkDescriptorSet (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkCopyDescriptorSet
DIAG: *** Emitting command decl for vkUpdateDescriptorSets
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter descriptorWriteCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDescriptorWrites to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     const VkWriteDescriptorSet*                 
DIAG: Aligning parameter descriptorCopyCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDescriptorCopies to column 48
DIAG: Adjust length of parameter decl from 30 to 48 :     const VkCopyDescriptorSet*                  
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkFramebufferCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkFramebufferCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkFramebufferCreateFlags
DIAG: *** Generating required dependent <type> VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImageView
DIAG: *** Skipping type VkImageView (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkFramebufferCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkFramebuffer
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkFramebuffer
DIAG: *** Emitting command decl for vkCreateFramebuffer
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     const VkFramebufferCreateInfo*              
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pFramebuffer to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkFramebuffer*                              
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkFramebuffer
DIAG: *** Skipping type VkFramebuffer (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyFramebuffer
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter framebuffer to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkFramebuffer                               
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkRenderPassCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkRenderPassCreateFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkRenderPassCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentDescription
DIAG: *** Generating required dependent <type> VkAttachmentDescriptionFlags
DIAG: *** Generating required dependent type VkAttachmentDescriptionFlagBits
DIAG: *** Type VkAttachmentDescriptionFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkAttachmentDescriptionFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkAttachmentDescriptionFlags
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkSampleCountFlagBits
DIAG: *** Skipping type VkSampleCountFlagBits (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentLoadOp
DIAG: *** Type VkAttachmentLoadOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkAttachmentLoadOp
DIAG: *** Generating required dependent <type> VkAttachmentStoreOp
DIAG: *** Type VkAttachmentStoreOp is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkAttachmentStoreOp
DIAG: *** Generating required dependent <type> VkAttachmentLoadOp
DIAG: *** Skipping type VkAttachmentLoadOp (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentStoreOp
DIAG: *** Skipping type VkAttachmentStoreOp (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Emitting type decl for VkAttachmentDescription
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSubpassDescription
DIAG: *** Generating required dependent <type> VkSubpassDescriptionFlags
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSubpassDescriptionFlags
DIAG: *** Generating required dependent <type> VkPipelineBindPoint
DIAG: *** Type VkPipelineBindPoint is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPipelineBindPoint
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentReference
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Emitting type decl for VkAttachmentReference
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentReference
DIAG: *** Skipping type VkAttachmentReference (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentReference
DIAG: *** Skipping type VkAttachmentReference (already declared)
DIAG: *** Generating required dependent <type> VkAttachmentReference
DIAG: *** Skipping type VkAttachmentReference (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkSubpassDescription
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSubpassDependency
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required dependent <type> VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Generating required dependent type VkAccessFlagBits
DIAG: *** Type VkAccessFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkAccessFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkAccessFlags
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> VkDependencyFlags
DIAG: *** Generating required dependent type VkDependencyFlagBits
DIAG: *** Type VkDependencyFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDependencyFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDependencyFlags
DIAG: *** Emitting type decl for VkSubpassDependency
DIAG: *** Emitting type decl for VkRenderPassCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Emitting command decl for vkCreateRenderPass
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 33 to 48 :     const VkRenderPassCreateInfo*               
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pRenderPass to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkRenderPass*                               
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyRenderPass
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter renderPass to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkRenderPass                                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Generating required parameter type VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Emitting command decl for vkGetRenderAreaGranularity
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter renderPass to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkRenderPass                                
DIAG: Aligning parameter pGranularity to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkExtent2D*                                 
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkCommandPoolCreateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkCommandPoolCreateFlags
DIAG: *** Generating required dependent type VkCommandPoolCreateFlagBits
DIAG: *** Type VkCommandPoolCreateFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCommandPoolCreateFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCommandPoolCreateFlags
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkCommandPoolCreateInfo
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkCommandPool
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkCommandPool
DIAG: *** Emitting command decl for vkCreateCommandPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     const VkCommandPoolCreateInfo*              
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pCommandPool to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkCommandPool*                              
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkCommandPool
DIAG: *** Skipping type VkCommandPool (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyCommandPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter commandPool to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkCommandPool                               
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkCommandPool
DIAG: *** Skipping type VkCommandPool (already declared)
DIAG: *** Generating required parameter type VkCommandPoolResetFlags
DIAG: *** Generating required dependent type VkCommandPoolResetFlagBits
DIAG: *** Type VkCommandPoolResetFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCommandPoolResetFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCommandPoolResetFlags
DIAG: *** Emitting command decl for vkResetCommandPool
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter commandPool to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkCommandPool                               
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 27 to 48 :     VkCommandPoolResetFlags                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkCommandBufferAllocateInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkCommandPool
DIAG: *** Skipping type VkCommandPool (already declared)
DIAG: *** Generating required dependent <type> VkCommandBufferLevel
DIAG: *** Type VkCommandBufferLevel is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCommandBufferLevel
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkCommandBufferAllocateInfo
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkAllocateCommandBuffers
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pAllocateInfo to column 48
DIAG: Adjust length of parameter decl from 38 to 48 :     const VkCommandBufferAllocateInfo*          
DIAG: Aligning parameter pCommandBuffers to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkCommandBuffer*                            
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkCommandPool
DIAG: *** Skipping type VkCommandPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkFreeCommandBuffers
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter commandPool to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkCommandPool                               
DIAG: Aligning parameter commandBufferCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCommandBuffers to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkCommandBuffer*                      
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkCommandBufferBeginInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkCommandBufferUsageFlags
DIAG: *** Generating required dependent type VkCommandBufferUsageFlagBits
DIAG: *** Type VkCommandBufferUsageFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCommandBufferUsageFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCommandBufferUsageFlags
DIAG: *** Generating required dependent <type> VkCommandBufferInheritanceInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkFramebuffer
DIAG: *** Skipping type VkFramebuffer (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkQueryControlFlags
DIAG: *** Generating required dependent type VkQueryControlFlagBits
DIAG: *** Type VkQueryControlFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkQueryControlFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkQueryControlFlags
DIAG: *** Generating required dependent <type> VkQueryPipelineStatisticFlags
DIAG: *** Skipping type VkQueryPipelineStatisticFlags (already declared)
DIAG: *** Emitting type decl for VkCommandBufferInheritanceInfo
DIAG: *** Emitting type decl for VkCommandBufferBeginInfo
DIAG: *** Emitting command decl for vkBeginCommandBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pBeginInfo to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     const VkCommandBufferBeginInfo*             
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkEndCommandBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkCommandBufferResetFlags
DIAG: *** Generating required dependent type VkCommandBufferResetFlagBits
DIAG: *** Type VkCommandBufferResetFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCommandBufferResetFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCommandBufferResetFlags
DIAG: *** Emitting command decl for vkResetCommandBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     VkCommandBufferResetFlags                   
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkPipelineBindPoint
DIAG: *** Skipping type VkPipelineBindPoint (already declared)
DIAG: *** Generating required parameter type VkPipeline
DIAG: *** Skipping type VkPipeline (already declared)
DIAG: *** Emitting command decl for vkCmdBindPipeline
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pipelineBindPoint to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     VkPipelineBindPoint                         
DIAG: Aligning parameter pipeline to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkPipeline                                  
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkViewport
DIAG: *** Skipping type VkViewport (already declared)
DIAG: *** Emitting command decl for vkCmdSetViewport
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter firstViewport to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter viewportCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pViewports to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     const VkViewport*                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkRect2D
DIAG: *** Skipping type VkRect2D (already declared)
DIAG: *** Emitting command decl for vkCmdSetScissor
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter firstScissor to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter scissorCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pScissors to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     const VkRect2D*                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting command decl for vkCmdSetLineWidth
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter lineWidth to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting command decl for vkCmdSetDepthBias
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter depthBiasConstantFactor to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: Aligning parameter depthBiasClamp to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: Aligning parameter depthBiasSlopeFactor to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting command decl for vkCmdSetBlendConstants
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter blendConstants to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     const float                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required parameter type float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting command decl for vkCmdSetDepthBounds
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter minDepthBounds to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: Aligning parameter maxDepthBounds to column 48
DIAG: Adjust length of parameter decl from 9 to 48 :     float                                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkStencilFaceFlags
DIAG: *** Generating required dependent type VkStencilFaceFlagBits
DIAG: *** Type VkStencilFaceFlagBits is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkStencilFaceFlagBits
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkStencilFaceFlags
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdSetStencilCompareMask
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter faceMask to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkStencilFaceFlags                          
DIAG: Aligning parameter compareMask to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkStencilFaceFlags
DIAG: *** Skipping type VkStencilFaceFlags (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdSetStencilWriteMask
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter faceMask to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkStencilFaceFlags                          
DIAG: Aligning parameter writeMask to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkStencilFaceFlags
DIAG: *** Skipping type VkStencilFaceFlags (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdSetStencilReference
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter faceMask to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkStencilFaceFlags                          
DIAG: Aligning parameter reference to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkPipelineBindPoint
DIAG: *** Skipping type VkPipelineBindPoint (already declared)
DIAG: *** Generating required parameter type VkPipelineLayout
DIAG: *** Skipping type VkPipelineLayout (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDescriptorSet
DIAG: *** Skipping type VkDescriptorSet (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdBindDescriptorSets
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pipelineBindPoint to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     VkPipelineBindPoint                         
DIAG: Aligning parameter layout to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPipelineLayout                            
DIAG: Aligning parameter firstSet to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter descriptorSetCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDescriptorSets to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkDescriptorSet*                      
DIAG: Aligning parameter dynamicOffsetCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDynamicOffsets to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     const uint32_t*                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkIndexType
DIAG: *** Type VkIndexType is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkIndexType
DIAG: *** Emitting command decl for vkCmdBindIndexBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter indexType to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkIndexType                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting command decl for vkCmdBindVertexBuffers
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter firstBinding to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter bindingCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pBuffers to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     const VkBuffer*                             
DIAG: Aligning parameter pOffsets to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     const VkDeviceSize*                         
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDraw
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter vertexCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter instanceCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter firstVertex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter firstInstance to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDrawIndexed
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter indexCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter instanceCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter firstIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter vertexOffset to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     int32_t                                     
DIAG: Aligning parameter firstInstance to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDrawIndirect
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter drawCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDrawIndexedIndirect
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter drawCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDispatch
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter x to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter y to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter z to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting command decl for vkCmdDispatchIndirect
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBufferCopy
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkBufferCopy
DIAG: *** Emitting command decl for vkCmdCopyBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter dstBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     const VkBufferCopy*                         
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageCopy
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Generating required dependent <type> VkImageAspectFlags
DIAG: *** Skipping type VkImageAspectFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkImageSubresourceLayers
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Emitting type decl for VkImageCopy
DIAG: *** Emitting command decl for vkCmdCopyImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter srcImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter dstImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter dstImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     const VkImageCopy*                          
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageBlit
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Emitting type decl for VkImageBlit
DIAG: *** Generating required parameter type VkFilter
DIAG: *** Skipping type VkFilter (already declared)
DIAG: *** Emitting command decl for vkCmdBlitImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter srcImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter dstImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter dstImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     const VkImageBlit*                          
DIAG: Aligning parameter filter to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFilter                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBufferImageCopy
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Emitting type decl for VkBufferImageCopy
DIAG: *** Emitting command decl for vkCmdCopyBufferToImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter dstImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter dstImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkBufferImageCopy*                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBufferImageCopy
DIAG: *** Skipping type VkBufferImageCopy (already declared)
DIAG: *** Emitting command decl for vkCmdCopyImageToBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter srcImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter dstBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkBufferImageCopy*                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting command decl for vkCmdUpdateBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter dstBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter dstOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter dataSize to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter pData to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     const void*                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdFillBuffer
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter dstBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter dstOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter size to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter data to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkClearColorValue
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkClearColorValue
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageSubresourceRange
DIAG: *** Skipping type VkImageSubresourceRange (already declared)
DIAG: *** Emitting command decl for vkCmdClearColorImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter imageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter pColor to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkClearColorValue*                    
DIAG: Aligning parameter rangeCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRanges to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     const VkImageSubresourceRange*              
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkClearDepthStencilValue
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkClearDepthStencilValue
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageSubresourceRange
DIAG: *** Skipping type VkImageSubresourceRange (already declared)
DIAG: *** Emitting command decl for vkCmdClearDepthStencilImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter image to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter imageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter pDepthStencil to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     const VkClearDepthStencilValue*             
DIAG: Aligning parameter rangeCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRanges to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     const VkImageSubresourceRange*              
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkClearAttachment
DIAG: *** Generating required dependent <type> VkImageAspectFlags
DIAG: *** Skipping type VkImageAspectFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkClearValue
DIAG: *** Generating required dependent <type> VkClearColorValue
DIAG: *** Skipping type VkClearColorValue (already declared)
DIAG: *** Generating required dependent <type> VkClearDepthStencilValue
DIAG: *** Skipping type VkClearDepthStencilValue (already declared)
DIAG: *** Emitting type decl for VkClearValue
DIAG: *** Emitting type decl for VkClearAttachment
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkClearRect
DIAG: *** Generating required dependent <type> VkRect2D
DIAG: *** Skipping type VkRect2D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkClearRect
DIAG: *** Emitting command decl for vkCmdClearAttachments
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter attachmentCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pAttachments to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     const VkClearAttachment*                    
DIAG: Aligning parameter rectCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRects to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     const VkClearRect*                          
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required parameter type VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageResolve
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkImageSubresourceLayers
DIAG: *** Skipping type VkImageSubresourceLayers (already declared)
DIAG: *** Generating required dependent <type> VkOffset3D
DIAG: *** Skipping type VkOffset3D (already declared)
DIAG: *** Generating required dependent <type> VkExtent3D
DIAG: *** Skipping type VkExtent3D (already declared)
DIAG: *** Emitting type decl for VkImageResolve
DIAG: *** Emitting command decl for vkCmdResolveImage
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter srcImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter dstImage to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkImage                                     
DIAG: Aligning parameter dstImageLayout to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageLayout                               
DIAG: Aligning parameter regionCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pRegions to column 48
DIAG: Adjust length of parameter decl from 25 to 48 :     const VkImageResolve*                       
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Emitting command decl for vkCmdSetEvent
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: Aligning parameter stageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Emitting command decl for vkCmdResetEvent
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter event to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkEvent                                     
DIAG: Aligning parameter stageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkEvent
DIAG: *** Skipping type VkEvent (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkMemoryBarrier
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Emitting type decl for VkMemoryBarrier
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBufferMemoryBarrier
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required dependent <type> VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Emitting type decl for VkBufferMemoryBarrier
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageMemoryBarrier
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> VkAccessFlags
DIAG: *** Skipping type VkAccessFlags (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required dependent <type> VkImageLayout
DIAG: *** Skipping type VkImageLayout (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required dependent <type> VkImageSubresourceRange
DIAG: *** Skipping type VkImageSubresourceRange (already declared)
DIAG: *** Emitting type decl for VkImageMemoryBarrier
DIAG: *** Emitting command decl for vkCmdWaitEvents
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter eventCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pEvents to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     const VkEvent*                              
DIAG: Aligning parameter srcStageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: Aligning parameter dstStageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: Aligning parameter memoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkMemoryBarrier*                      
DIAG: Aligning parameter bufferMemoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pBufferMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkBufferMemoryBarrier*                
DIAG: Aligning parameter imageMemoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pImageMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     const VkImageMemoryBarrier*                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlags
DIAG: *** Skipping type VkPipelineStageFlags (already declared)
DIAG: *** Generating required parameter type VkDependencyFlags
DIAG: *** Skipping type VkDependencyFlags (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkMemoryBarrier
DIAG: *** Skipping type VkMemoryBarrier (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBufferMemoryBarrier
DIAG: *** Skipping type VkBufferMemoryBarrier (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImageMemoryBarrier
DIAG: *** Skipping type VkImageMemoryBarrier (already declared)
DIAG: *** Emitting command decl for vkCmdPipelineBarrier
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter srcStageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: Aligning parameter dstStageMask to column 48
DIAG: Adjust length of parameter decl from 24 to 48 :     VkPipelineStageFlags                        
DIAG: Aligning parameter dependencyFlags to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkDependencyFlags                           
DIAG: Aligning parameter memoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkMemoryBarrier*                      
DIAG: Aligning parameter bufferMemoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pBufferMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkBufferMemoryBarrier*                
DIAG: Aligning parameter imageMemoryBarrierCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pImageMemoryBarriers to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     const VkImageMemoryBarrier*                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkQueryControlFlags
DIAG: *** Skipping type VkQueryControlFlags (already declared)
DIAG: *** Emitting command decl for vkCmdBeginQuery
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter query to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     VkQueryControlFlags                         
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdEndQuery
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter query to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdResetQueryPool
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter firstQuery to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter queryCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkPipelineStageFlagBits
DIAG: *** Skipping type VkPipelineStageFlagBits (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdWriteTimestamp
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pipelineStage to column 48
DIAG: Adjust length of parameter decl from 27 to 48 :     VkPipelineStageFlagBits                     
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter query to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkQueryPool
DIAG: *** Skipping type VkQueryPool (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkQueryResultFlags
DIAG: *** Skipping type VkQueryResultFlags (already declared)
DIAG: *** Emitting command decl for vkCmdCopyQueryPoolResults
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter queryPool to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkQueryPool                                 
DIAG: Aligning parameter firstQuery to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter queryCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter dstBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter dstOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkQueryResultFlags                          
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkPipelineLayout
DIAG: *** Skipping type VkPipelineLayout (already declared)
DIAG: *** Generating required parameter type VkShaderStageFlags
DIAG: *** Skipping type VkShaderStageFlags (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting command decl for vkCmdPushConstants
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter layout to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPipelineLayout                            
DIAG: Aligning parameter stageFlags to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkShaderStageFlags                          
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter size to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pValues to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     const void*                                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkRenderPassBeginInfo
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkRenderPass
DIAG: *** Skipping type VkRenderPass (already declared)
DIAG: *** Generating required dependent <type> VkFramebuffer
DIAG: *** Skipping type VkFramebuffer (already declared)
DIAG: *** Generating required dependent <type> VkRect2D
DIAG: *** Skipping type VkRect2D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkClearValue
DIAG: *** Skipping type VkClearValue (already declared)
DIAG: *** Emitting type decl for VkRenderPassBeginInfo
DIAG: *** Generating required parameter type VkSubpassContents
DIAG: *** Type VkSubpassContents is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSubpassContents
DIAG: *** Emitting command decl for vkCmdBeginRenderPass
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pRenderPassBegin to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkRenderPassBeginInfo*                
DIAG: Aligning parameter contents to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkSubpassContents                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkSubpassContents
DIAG: *** Skipping type VkSubpassContents (already declared)
DIAG: *** Emitting command decl for vkCmdNextSubpass
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter contents to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkSubpassContents                           
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkCmdEndRenderPass
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkCmdExecuteCommands
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter commandBufferCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCommandBuffers to column 48
DIAG: Adjust length of parameter decl from 26 to 48 :     const VkCommandBuffer*                      
DIAG: *** Skipping type VkBufferMemoryBarrier (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDispatchIndirectCommand
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDrawIndexedIndirectCommand
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDrawIndirectCommand
DIAG: *** Skipping type VkImageMemoryBarrier (already declared)
DIAG: *** Skipping type VkMemoryBarrier (already declared)
DIAG: ParameterValidation: Generating VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV for VkDedicatedAllocationMemoryAllocateInfoNV structure type that was not defined by the current feature
DIAG: ParameterValidation: No validation for VkQueryPoolCreateInfo pipelineStatistics
DIAG: ParameterValidation: Generating VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV for VkDedicatedAllocationBufferCreateInfoNV structure type that was not defined by the current feature
DIAG: ParameterValidation: No validation for VkBufferCreateInfo pQueueFamilyIndices
DIAG: ParameterValidation: Generating VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV for VkDedicatedAllocationImageCreateInfoNV structure type that was not defined by the current feature
DIAG: ParameterValidation: No validation for VkImageCreateInfo pQueueFamilyIndices
DIAG: ParameterValidation: No validation for VkPipelineViewportStateCreateInfo pViewports
DIAG: ParameterValidation: No validation for VkPipelineViewportStateCreateInfo pScissors
DIAG: ParameterValidation: Generating VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD for VkPipelineRasterizationStateRasterizationOrderAMD structure type that was not defined by the current feature
DIAG: ParameterValidation: No validation for VkPipelineColorBlendStateCreateInfo logicOp
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo pTessellationState
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo pViewportState
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo pMultisampleState
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo pDepthStencilState
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo pColorBlendState
DIAG: ParameterValidation: No validation for VkGraphicsPipelineCreateInfo basePipelineHandle
DIAG: ParameterValidation: No validation for VkComputePipelineCreateInfo basePipelineHandle
DIAG: ParameterValidation: No validation for VkSamplerCreateInfo compareOp
DIAG: ParameterValidation: No validation for VkSamplerCreateInfo borderColor
DIAG: ParameterValidation: No validation for VkDescriptorSetLayoutBinding stageFlags
DIAG: ParameterValidation: No validation for VkDescriptorSetLayoutBinding pImmutableSamplers
DIAG: ParameterValidation: No validation for VkDescriptorImageInfo sampler
DIAG: ParameterValidation: No validation for VkDescriptorImageInfo imageView
DIAG: ParameterValidation: No validation for VkDescriptorImageInfo imageLayout
DIAG: ParameterValidation: No validation for VkWriteDescriptorSet pImageInfo
DIAG: ParameterValidation: No validation for VkWriteDescriptorSet pBufferInfo
DIAG: ParameterValidation: No validation for VkWriteDescriptorSet pTexelBufferView
DIAG: ParameterValidation: No validation for VkCommandBufferInheritanceInfo renderPass
DIAG: ParameterValidation: No validation for VkCommandBufferInheritanceInfo framebuffer
DIAG: ParameterValidation: No validation for VkCommandBufferInheritanceInfo queryFlags
DIAG: ParameterValidation: No validation for VkCommandBufferInheritanceInfo pipelineStatistics
DIAG: ParameterValidation: No validation for VkCommandBufferBeginInfo pInheritanceInfo
DIAG: ParameterValidation: No validation for vkFreeDescriptorSets pDescriptorSets
DIAG: ParameterValidation: No validation for vkFreeCommandBuffers pCommandBuffers
DIAG: *** PASS 2: Generating interface for VK_KHR_surface
DIAG: *** Emitting enum decl for VK_KHR_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_ERROR_SURFACE_LOST_KHR
DIAG: *** Emitting enum decl for VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
DIAG: *** Emitting enum decl for VK_COLORSPACE_SRGB_NONLINEAR_KHR
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkSurfaceKHR
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroySurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter surface to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSurfaceKHR                                
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceSurfaceSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter surface to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSurfaceKHR                                
DIAG: Aligning parameter pSupported to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     VkBool32*                                   
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Generating required parameter type VkSurfaceCapabilitiesKHR
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSurfaceTransformFlagsKHR
DIAG: *** Generating required dependent type VkSurfaceTransformFlagBitsKHR
DIAG: *** Type VkSurfaceTransformFlagBitsKHR is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkSurfaceTransformFlagBitsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSurfaceTransformFlagsKHR
DIAG: *** Generating required dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** Skipping type VkSurfaceTransformFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> VkCompositeAlphaFlagsKHR
DIAG: *** Generating required dependent type VkCompositeAlphaFlagBitsKHR
DIAG: *** Type VkCompositeAlphaFlagBitsKHR is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkCompositeAlphaFlagBitsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkCompositeAlphaFlagsKHR
DIAG: *** Generating required dependent <type> VkImageUsageFlags
DIAG: *** Skipping type VkImageUsageFlags (already declared)
DIAG: *** Emitting type decl for VkSurfaceCapabilitiesKHR
DIAG: *** Emitting command decl for vkGetPhysicalDeviceSurfaceCapabilitiesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter surface to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSurfaceKHR                                
DIAG: Aligning parameter pSurfaceCapabilities to column 48
DIAG: Adjust length of parameter decl from 29 to 48 :     VkSurfaceCapabilitiesKHR*                   
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSurfaceFormatKHR
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkColorSpaceKHR
DIAG: *** Type VkColorSpaceKHR is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkColorSpaceKHR
DIAG: *** Emitting type decl for VkSurfaceFormatKHR
DIAG: *** Emitting command decl for vkGetPhysicalDeviceSurfaceFormatsKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter surface to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSurfaceKHR                                
DIAG: Aligning parameter pSurfaceFormatCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pSurfaceFormats to column 48
DIAG: Adjust length of parameter decl from 23 to 48 :     VkSurfaceFormatKHR*                         
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkPresentModeKHR
DIAG: *** Type VkPresentModeKHR is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkPresentModeKHR
DIAG: *** Emitting command decl for vkGetPhysicalDeviceSurfacePresentModesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter surface to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkSurfaceKHR                                
DIAG: Aligning parameter pPresentModeCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pPresentModes to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkPresentModeKHR*                           
DIAG: *** PASS 2: Generating interface for VK_KHR_swapchain
DIAG: *** Emitting enum decl for VK_KHR_SWAPCHAIN_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_SWAPCHAIN_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
DIAG: *** Emitting enum decl for VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
DIAG: *** Emitting enum decl for VK_SUBOPTIMAL_KHR
DIAG: *** Emitting enum decl for VK_ERROR_OUT_OF_DATE_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSwapchainCreateInfoKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkSwapchainCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkSwapchainCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required dependent <type> VkColorSpaceKHR
DIAG: *** Skipping type VkColorSpaceKHR (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkImageUsageFlags
DIAG: *** Skipping type VkImageUsageFlags (already declared)
DIAG: *** Generating required dependent <type> VkSharingMode
DIAG: *** Skipping type VkSharingMode (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** Skipping type VkSurfaceTransformFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> VkCompositeAlphaFlagBitsKHR
DIAG: *** Skipping type VkCompositeAlphaFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> VkPresentModeKHR
DIAG: *** Skipping type VkPresentModeKHR (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkSwapchainKHR
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkSwapchainKHR
DIAG: *** Emitting type decl for VkSwapchainCreateInfoKHR
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Emitting command decl for vkCreateSwapchainKHR
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     const VkSwapchainCreateInfoKHR*             
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSwapchain to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkSwapchainKHR*                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroySwapchainKHR
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter swapchain to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkSwapchainKHR                              
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Emitting command decl for vkGetSwapchainImagesKHR
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter swapchain to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkSwapchainKHR                              
DIAG: Aligning parameter pSwapchainImageCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pSwapchainImages to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkImage*                                    
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Generating required parameter type uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required parameter type VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Generating required parameter type VkFence
DIAG: *** Skipping type VkFence (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkAcquireNextImageKHR
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter swapchain to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkSwapchainKHR                              
DIAG: Aligning parameter timeout to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint64_t                                    
DIAG: Aligning parameter semaphore to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkSemaphore                                 
DIAG: Aligning parameter fence to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkFence                                     
DIAG: Aligning parameter pImageIndex to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkQueue
DIAG: *** Skipping type VkQueue (already declared)
DIAG: *** Generating required parameter type VkPresentInfoKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSemaphore
DIAG: *** Skipping type VkSemaphore (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Emitting type decl for VkPresentInfoKHR
DIAG: *** Emitting command decl for vkQueuePresentKHR
DIAG: Aligning parameter queue to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     VkQueue                                     
DIAG: Aligning parameter pPresentInfo to column 48
DIAG: Adjust length of parameter decl from 27 to 48 :     const VkPresentInfoKHR*                     
DIAG: ParameterValidation: No validation for VkSwapchainCreateInfoKHR pQueueFamilyIndices
DIAG: *** PASS 2: Generating interface for VK_KHR_display
DIAG: *** Generating required dependent type VkDisplayPlaneAlphaFlagBitsKHR
DIAG: *** Type VkDisplayPlaneAlphaFlagBitsKHR is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDisplayPlaneAlphaFlagBitsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDisplayPlaneAlphaFlagsKHR
DIAG: *** Skipping type VkDisplayPlaneAlphaFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> VkDisplayKHR
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDisplayKHR
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkSurfaceTransformFlagsKHR
DIAG: *** Skipping type VkSurfaceTransformFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkDisplayPropertiesKHR
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDisplayModeParametersKHR
DIAG: *** Generating required dependent <type> VkDisplayModeKHR
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDisplayModeKHR
DIAG: *** Generating required dependent <type> VkDisplayModeParametersKHR
DIAG: *** Skipping type VkDisplayModeParametersKHR (already declared)
DIAG: *** Emitting type decl for VkDisplayModePropertiesKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDisplayModeCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDisplayModeCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkDisplayModeParametersKHR
DIAG: *** Skipping type VkDisplayModeParametersKHR (already declared)
DIAG: *** Emitting type decl for VkDisplayModeCreateInfoKHR
DIAG: *** Generating required dependent <type> VkDisplayPlaneAlphaFlagsKHR
DIAG: *** Skipping type VkDisplayPlaneAlphaFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> VkOffset2D
DIAG: *** Skipping type VkOffset2D (already declared)
DIAG: *** Generating required dependent <type> VkOffset2D
DIAG: *** Skipping type VkOffset2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkOffset2D
DIAG: *** Skipping type VkOffset2D (already declared)
DIAG: *** Generating required dependent <type> VkOffset2D
DIAG: *** Skipping type VkOffset2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Emitting type decl for VkDisplayPlaneCapabilitiesKHR
DIAG: *** Generating required dependent <type> VkDisplayKHR
DIAG: *** Skipping type VkDisplayKHR (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting type decl for VkDisplayPlanePropertiesKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDisplaySurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDisplaySurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkDisplayModeKHR
DIAG: *** Skipping type VkDisplayModeKHR (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkSurfaceTransformFlagBitsKHR
DIAG: *** Skipping type VkSurfaceTransformFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Generating required dependent <type> VkDisplayPlaneAlphaFlagBitsKHR
DIAG: *** Skipping type VkDisplayPlaneAlphaFlagBitsKHR (already declared)
DIAG: *** Generating required dependent <type> VkExtent2D
DIAG: *** Skipping type VkExtent2D (already declared)
DIAG: *** Emitting type decl for VkDisplaySurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_DISPLAY_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_DISPLAY_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDisplayPropertiesKHR
DIAG: *** Skipping type VkDisplayPropertiesKHR (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceDisplayPropertiesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 27 to 48 :     VkDisplayPropertiesKHR*                     
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDisplayPlanePropertiesKHR
DIAG: *** Skipping type VkDisplayPlanePropertiesKHR (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceDisplayPlanePropertiesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     VkDisplayPlanePropertiesKHR*                
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDisplayKHR
DIAG: *** Skipping type VkDisplayKHR (already declared)
DIAG: *** Emitting command decl for vkGetDisplayPlaneSupportedDisplaysKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter planeIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pDisplayCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pDisplays to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkDisplayKHR*                               
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkDisplayKHR
DIAG: *** Skipping type VkDisplayKHR (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDisplayModePropertiesKHR
DIAG: *** Skipping type VkDisplayModePropertiesKHR (already declared)
DIAG: *** Emitting command decl for vkGetDisplayModePropertiesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter display to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDisplayKHR                                
DIAG: Aligning parameter pPropertyCount to column 48
DIAG: Adjust length of parameter decl from 13 to 48 :     uint32_t*                                   
DIAG: Aligning parameter pProperties to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     VkDisplayModePropertiesKHR*                 
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkDisplayKHR
DIAG: *** Skipping type VkDisplayKHR (already declared)
DIAG: *** Generating required parameter type VkDisplayModeCreateInfoKHR
DIAG: *** Skipping type VkDisplayModeCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDisplayModeKHR
DIAG: *** Skipping type VkDisplayModeKHR (already declared)
DIAG: *** Emitting command decl for vkCreateDisplayModeKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter display to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDisplayKHR                                
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     const VkDisplayModeCreateInfoKHR*           
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pMode to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkDisplayModeKHR*                           
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkDisplayModeKHR
DIAG: *** Skipping type VkDisplayModeKHR (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkDisplayPlaneCapabilitiesKHR
DIAG: *** Skipping type VkDisplayPlaneCapabilitiesKHR (already declared)
DIAG: *** Emitting command decl for vkGetDisplayPlaneCapabilitiesKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter mode to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkDisplayModeKHR                            
DIAG: Aligning parameter planeIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCapabilities to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     VkDisplayPlaneCapabilitiesKHR*              
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkDisplaySurfaceCreateInfoKHR
DIAG: *** Skipping type VkDisplaySurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateDisplayPlaneSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 40 to 48 :     const VkDisplaySurfaceCreateInfoKHR*        
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** PASS 2: Generating interface for VK_KHR_display_swapchain
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkRect2D
DIAG: *** Skipping type VkRect2D (already declared)
DIAG: *** Generating required dependent <type> VkRect2D
DIAG: *** Skipping type VkRect2D (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkDisplayPresentInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR
DIAG: *** Emitting enum decl for VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type VkSwapchainCreateInfoKHR
DIAG: *** Skipping type VkSwapchainCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSwapchainKHR
DIAG: *** Skipping type VkSwapchainKHR (already declared)
DIAG: *** Emitting command decl for vkCreateSharedSwapchainsKHR
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter swapchainCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter pCreateInfos to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     const VkSwapchainCreateInfoKHR*             
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSwapchains to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkSwapchainKHR*                             
DIAG: *** PASS 2: Generating interface for VK_KHR_xlib_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkXlibSurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkXlibSurfaceCreateFlagsKHR
DIAG: *** Skipping type VkXlibSurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> Display
DIAG: *** Generating required dependent type X11/Xlib.h
DIAG: *** Emitting type decl for X11/Xlib.h
DIAG: *** Emitting type decl for Display
DIAG: *** Generating required dependent <type> Window
DIAG: *** Generating required dependent type X11/Xlib.h
DIAG: *** Skipping type X11/Xlib.h (already declared)
DIAG: *** Emitting type decl for Window
DIAG: *** Emitting type decl for VkXlibSurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_XLIB_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_XLIB_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkXlibSurfaceCreateInfoKHR
DIAG: *** Skipping type VkXlibSurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateXlibSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     const VkXlibSurfaceCreateInfoKHR*           
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type Display
DIAG: *** Skipping type Display (already declared)
DIAG: *** Generating required parameter type VisualID
DIAG: *** Generating required dependent type X11/Xlib.h
DIAG: *** Skipping type X11/Xlib.h (already declared)
DIAG: *** Emitting type decl for VisualID
DIAG: *** Emitting command decl for vkGetPhysicalDeviceXlibPresentationSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter dpy to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     Display*                                    
DIAG: Aligning parameter visualID to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VisualID                                    
DIAG: *** PASS 2: Generating interface for VK_KHR_xcb_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkXcbSurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkXcbSurfaceCreateFlagsKHR
DIAG: *** Skipping type VkXcbSurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> xcb_connection_t
DIAG: *** Generating required dependent type xcb/xcb.h
DIAG: *** Emitting type decl for xcb/xcb.h
DIAG: *** Emitting type decl for xcb_connection_t
DIAG: *** Generating required dependent <type> xcb_window_t
DIAG: *** Generating required dependent type xcb/xcb.h
DIAG: *** Skipping type xcb/xcb.h (already declared)
DIAG: *** Emitting type decl for xcb_window_t
DIAG: *** Emitting type decl for VkXcbSurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_XCB_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_XCB_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkXcbSurfaceCreateInfoKHR
DIAG: *** Skipping type VkXcbSurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateXcbSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 36 to 48 :     const VkXcbSurfaceCreateInfoKHR*            
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type xcb_connection_t
DIAG: *** Skipping type xcb_connection_t (already declared)
DIAG: *** Generating required parameter type xcb_visualid_t
DIAG: *** Generating required dependent type xcb/xcb.h
DIAG: *** Skipping type xcb/xcb.h (already declared)
DIAG: *** Emitting type decl for xcb_visualid_t
DIAG: *** Emitting command decl for vkGetPhysicalDeviceXcbPresentationSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter connection to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     xcb_connection_t*                           
DIAG: Aligning parameter visual_id to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     xcb_visualid_t                              
DIAG: *** PASS 2: Generating interface for VK_KHR_wayland_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkWaylandSurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkWaylandSurfaceCreateFlagsKHR
DIAG: *** Skipping type VkWaylandSurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> wl_display
DIAG: *** Generating required dependent type wayland-client.h
DIAG: *** Emitting type decl for wayland-client.h
DIAG: *** Emitting type decl for wl_display
DIAG: *** Generating required dependent <type> wl_surface
DIAG: *** Generating required dependent type wayland-client.h
DIAG: *** Skipping type wayland-client.h (already declared)
DIAG: *** Emitting type decl for wl_surface
DIAG: *** Emitting type decl for VkWaylandSurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_WAYLAND_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkWaylandSurfaceCreateInfoKHR
DIAG: *** Skipping type VkWaylandSurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateWaylandSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 40 to 48 :     const VkWaylandSurfaceCreateInfoKHR*        
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type wl_display
DIAG: *** Skipping type wl_display (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceWaylandPresentationSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter display to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     struct wl_display*                          
DIAG: *** PASS 2: Generating interface for VK_KHR_mir_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkMirSurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkMirSurfaceCreateFlagsKHR
DIAG: *** Skipping type VkMirSurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> MirConnection
DIAG: *** Generating required dependent type mir_toolkit/client_types.h
DIAG: *** Emitting type decl for mir_toolkit/client_types.h
DIAG: *** Emitting type decl for MirConnection
DIAG: *** Generating required dependent <type> MirSurface
DIAG: *** Generating required dependent type mir_toolkit/client_types.h
DIAG: *** Skipping type mir_toolkit/client_types.h (already declared)
DIAG: *** Emitting type decl for MirSurface
DIAG: *** Emitting type decl for VkMirSurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_MIR_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_MIR_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkMirSurfaceCreateInfoKHR
DIAG: *** Skipping type VkMirSurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateMirSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 36 to 48 :     const VkMirSurfaceCreateInfoKHR*            
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type MirConnection
DIAG: *** Skipping type MirConnection (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceMirPresentationSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter connection to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     MirConnection*                              
DIAG: *** PASS 2: Generating interface for VK_KHR_android_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkAndroidSurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkAndroidSurfaceCreateFlagsKHR
DIAG: *** Skipping type VkAndroidSurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> ANativeWindow
DIAG: *** Generating required dependent type android/native_window.h
DIAG: *** Emitting type decl for android/native_window.h
DIAG: *** Emitting type decl for ANativeWindow
DIAG: *** Emitting type decl for VkAndroidSurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_ANDROID_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkAndroidSurfaceCreateInfoKHR
DIAG: *** Skipping type VkAndroidSurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateAndroidSurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 40 to 48 :     const VkAndroidSurfaceCreateInfoKHR*        
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** PASS 2: Generating interface for VK_KHR_win32_surface
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkWin32SurfaceCreateFlagsKHR
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkWin32SurfaceCreateFlagsKHR
DIAG: *** Skipping type VkWin32SurfaceCreateFlagsKHR (already declared)
DIAG: *** Generating required dependent <type> HINSTANCE
DIAG: *** Generating required dependent type windows.h
DIAG: *** Emitting type decl for windows.h
DIAG: *** Emitting type decl for HINSTANCE
DIAG: *** Generating required dependent <type> HWND
DIAG: *** Generating required dependent type windows.h
DIAG: *** Skipping type windows.h (already declared)
DIAG: *** Emitting type decl for HWND
DIAG: *** Emitting type decl for VkWin32SurfaceCreateInfoKHR
DIAG: *** Emitting enum decl for VK_KHR_WIN32_SURFACE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_WIN32_SURFACE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkWin32SurfaceCreateInfoKHR
DIAG: *** Skipping type VkWin32SurfaceCreateInfoKHR (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkSurfaceKHR
DIAG: *** Skipping type VkSurfaceKHR (already declared)
DIAG: *** Emitting command decl for vkCreateWin32SurfaceKHR
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter pCreateInfo to column 48
DIAG: Adjust length of parameter decl from 38 to 48 :     const VkWin32SurfaceCreateInfoKHR*          
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: Aligning parameter pSurface to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkSurfaceKHR*                               
DIAG: *** Generating required parameter type VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceWin32PresentationSupportKHR
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter queueFamilyIndex to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** PASS 2: Generating interface for VK_KHR_sampler_mirror_clamp_to_edge
DIAG: *** Emitting enum decl for VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
DIAG: *** PASS 2: Generating interface for VK_EXT_debug_report
DIAG: *** Type VkDebugReportObjectTypeEXT is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDebugReportObjectTypeEXT
DIAG: *** Type VkDebugReportErrorEXT is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDebugReportErrorEXT
DIAG: *** Emitting enum decl for VK_EXT_DEBUG_REPORT_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_EXT_DEBUG_REPORT_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
DIAG: *** Emitting enum decl for VK_ERROR_VALIDATION_FAILED_EXT
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkDebugReportCallbackCreateInfoEXT
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDebugReportFlagsEXT
DIAG: *** Generating required dependent type VkDebugReportFlagBitsEXT
DIAG: *** Type VkDebugReportFlagBitsEXT is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkDebugReportFlagBitsEXT
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkDebugReportFlagsEXT
DIAG: *** Generating required dependent <type> PFN_vkDebugReportCallbackEXT
DIAG: *** Generating required dependent <type> VkDebugReportFlagsEXT
DIAG: *** Skipping type VkDebugReportFlagsEXT (already declared)
DIAG: *** Generating required dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** Skipping type VkDebugReportObjectTypeEXT (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for PFN_vkDebugReportCallbackEXT
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for VkDebugReportCallbackCreateInfoEXT
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Generating required parameter type VkDebugReportCallbackEXT
DIAG: *** Generating required dependent <type> VK_DEFINE_NON_DISPATCHABLE_HANDLE
DIAG: *** Skipping type VK_DEFINE_NON_DISPATCHABLE_HANDLE (already declared)
DIAG: *** Emitting type decl for VkDebugReportCallbackEXT
DIAG: *** Emitting command decl for vkCreateDebugReportCallbackEXT
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkDebugReportCallbackEXT
DIAG: *** Skipping type VkDebugReportCallbackEXT (already declared)
DIAG: *** Generating required parameter type VkAllocationCallbacks
DIAG: *** Skipping type VkAllocationCallbacks (already declared)
DIAG: *** Emitting command decl for vkDestroyDebugReportCallbackEXT
DIAG: Aligning parameter instance to column 48
DIAG: Adjust length of parameter decl from 14 to 48 :     VkInstance                                  
DIAG: Aligning parameter callback to column 48
DIAG: Adjust length of parameter decl from 28 to 48 :     VkDebugReportCallbackEXT                    
DIAG: Aligning parameter pAllocator to column 48
DIAG: Adjust length of parameter decl from 32 to 48 :     const VkAllocationCallbacks*                
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkInstance
DIAG: *** Skipping type VkInstance (already declared)
DIAG: *** Generating required parameter type VkDebugReportFlagsEXT
DIAG: *** Skipping type VkDebugReportFlagsEXT (already declared)
DIAG: *** Generating required parameter type VkDebugReportObjectTypeEXT
DIAG: *** Skipping type VkDebugReportObjectTypeEXT (already declared)
DIAG: *** Generating required parameter type uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required parameter type size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required parameter type int32_t
DIAG: *** Skipping type int32_t (already declared)
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required parameter type char
DIAG: *** Skipping type char (already declared)
DIAG: *** Emitting command decl for vkDebugReportMessageEXT
DIAG: *** PASS 2: Generating interface for VK_NV_glsl_shader
DIAG: *** Emitting enum decl for VK_NV_GLSL_SHADER_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_GLSL_SHADER_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_ERROR_INVALID_SHADER_NV
DIAG: *** PASS 2: Generating interface for VK_IMG_filter_cubic
DIAG: *** Emitting enum decl for VK_IMG_FILTER_CUBIC_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_IMG_FILTER_CUBIC_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_FILTER_CUBIC_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG
DIAG: *** PASS 2: Generating interface for VK_AMD_rasterization_order
DIAG: *** Type VkRasterizationOrderAMD is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkRasterizationOrderAMD
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkRasterizationOrderAMD
DIAG: *** Skipping type VkRasterizationOrderAMD (already declared)
DIAG: *** Emitting type decl for VkPipelineRasterizationStateRasterizationOrderAMD
DIAG: *** Emitting enum decl for VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
DIAG: *** PASS 2: Generating interface for VK_AMD_shader_trinary_minmax
DIAG: *** Emitting enum decl for VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME
DIAG: *** PASS 2: Generating interface for VK_AMD_shader_explicit_vertex_parameter
DIAG: *** Emitting enum decl for VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME
DIAG: *** PASS 2: Generating interface for VK_EXT_debug_marker
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** Skipping type VkDebugReportObjectTypeEXT (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Emitting type decl for VkDebugMarkerObjectNameInfoEXT
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkDebugReportObjectTypeEXT
DIAG: *** Skipping type VkDebugReportObjectTypeEXT (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required dependent <type> size_t
DIAG: *** Skipping type size_t (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Emitting type decl for VkDebugMarkerObjectTagInfoEXT
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> char
DIAG: *** Skipping type char (already declared)
DIAG: *** Generating required dependent <type> float
DIAG: *** Skipping type float (already declared)
DIAG: *** Emitting type decl for VkDebugMarkerMarkerInfoEXT
DIAG: *** Emitting enum decl for VK_EXT_DEBUG_MARKER_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_EXT_DEBUG_MARKER_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDebugMarkerObjectTagInfoEXT
DIAG: *** Skipping type VkDebugMarkerObjectTagInfoEXT (already declared)
DIAG: *** Emitting command decl for vkDebugMarkerSetObjectTagEXT
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pTagInfo to column 48
DIAG: Adjust length of parameter decl from 34 to 48 :     VkDebugMarkerObjectTagInfoEXT*              
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDebugMarkerObjectNameInfoEXT
DIAG: *** Skipping type VkDebugMarkerObjectNameInfoEXT (already declared)
DIAG: *** Emitting command decl for vkDebugMarkerSetObjectNameEXT
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter pNameInfo to column 48
DIAG: Adjust length of parameter decl from 35 to 48 :     VkDebugMarkerObjectNameInfoEXT*             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkDebugMarkerMarkerInfoEXT
DIAG: *** Skipping type VkDebugMarkerMarkerInfoEXT (already declared)
DIAG: *** Emitting command decl for vkCmdDebugMarkerBeginEXT
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pMarkerInfo to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     VkDebugMarkerMarkerInfoEXT*                 
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Emitting command decl for vkCmdDebugMarkerEndEXT
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkDebugMarkerMarkerInfoEXT
DIAG: *** Skipping type VkDebugMarkerMarkerInfoEXT (already declared)
DIAG: *** Emitting command decl for vkCmdDebugMarkerInsertEXT
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter pMarkerInfo to column 48
DIAG: Adjust length of parameter decl from 31 to 48 :     VkDebugMarkerMarkerInfoEXT*                 
DIAG: *** PASS 2: Generating interface for VK_AMD_gcn_shader
DIAG: *** Emitting enum decl for VK_AMD_GCN_SHADER_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_AMD_GCN_SHADER_EXTENSION_NAME
DIAG: *** PASS 2: Generating interface for VK_NV_dedicated_allocation
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkDedicatedAllocationImageCreateInfoNV
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkBool32
DIAG: *** Skipping type VkBool32 (already declared)
DIAG: *** Emitting type decl for VkDedicatedAllocationBufferCreateInfoNV
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkImage
DIAG: *** Skipping type VkImage (already declared)
DIAG: *** Generating required dependent <type> VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Emitting type decl for VkDedicatedAllocationMemoryAllocateInfoNV
DIAG: *** Emitting enum decl for VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
DIAG: *** PASS 2: Generating interface for VK_AMD_draw_indirect_count
DIAG: *** Emitting enum decl for VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_EXTENSION_NAME
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDrawIndirectCountAMD
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter countBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter countBufferOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter maxDrawCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** Generating required parameter type void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required parameter type VkCommandBuffer
DIAG: *** Skipping type VkCommandBuffer (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type VkBuffer
DIAG: *** Skipping type VkBuffer (already declared)
DIAG: *** Generating required parameter type VkDeviceSize
DIAG: *** Skipping type VkDeviceSize (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required parameter type uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Emitting command decl for vkCmdDrawIndexedIndirectCountAMD
DIAG: Aligning parameter commandBuffer to column 48
DIAG: Adjust length of parameter decl from 19 to 48 :     VkCommandBuffer                             
DIAG: Aligning parameter buffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter offset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter countBuffer to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkBuffer                                    
DIAG: Aligning parameter countBufferOffset to column 48
DIAG: Adjust length of parameter decl from 16 to 48 :     VkDeviceSize                                
DIAG: Aligning parameter maxDrawCount to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: Aligning parameter stride to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     uint32_t                                    
DIAG: *** PASS 2: Generating interface for VK_IMG_format_pvrtc
DIAG: *** Emitting enum decl for VK_IMG_FORMAT_PVRTC_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_IMG_FORMAT_PVRTC_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG
DIAG: *** Emitting enum decl for VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
DIAG: *** PASS 2: Generating interface for VK_NV_external_memory_capabilities
DIAG: *** Generating required dependent type VkExternalMemoryHandleTypeFlagBitsNV
DIAG: *** Type VkExternalMemoryHandleTypeFlagBitsNV is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkExternalMemoryHandleTypeFlagBitsNV
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagBitsNV (already declared)
DIAG: *** Generating required dependent type VkExternalMemoryFeatureFlagBitsNV
DIAG: *** Type VkExternalMemoryFeatureFlagBitsNV is an enum group, so generate that instead
DIAG: *** Emitting type decl for VkExternalMemoryFeatureFlagBitsNV
DIAG: *** Generating required dependent <type> VkFlags
DIAG: *** Skipping type VkFlags (already declared)
DIAG: *** Emitting type decl for VkExternalMemoryFeatureFlagsNV
DIAG: *** Skipping type VkExternalMemoryFeatureFlagBitsNV (already declared)
DIAG: *** Generating required dependent <type> VkImageFormatProperties
DIAG: *** Skipping type VkImageFormatProperties (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryFeatureFlagsNV
DIAG: *** Skipping type VkExternalMemoryFeatureFlagsNV (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Emitting type decl for VkExternalImageFormatPropertiesNV
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkPhysicalDevice
DIAG: *** Skipping type VkPhysicalDevice (already declared)
DIAG: *** Generating required parameter type VkFormat
DIAG: *** Skipping type VkFormat (already declared)
DIAG: *** Generating required parameter type VkImageType
DIAG: *** Skipping type VkImageType (already declared)
DIAG: *** Generating required parameter type VkImageTiling
DIAG: *** Skipping type VkImageTiling (already declared)
DIAG: *** Generating required parameter type VkImageUsageFlags
DIAG: *** Skipping type VkImageUsageFlags (already declared)
DIAG: *** Generating required parameter type VkImageCreateFlags
DIAG: *** Skipping type VkImageCreateFlags (already declared)
DIAG: *** Generating required parameter type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Generating required parameter type VkExternalImageFormatPropertiesNV
DIAG: *** Skipping type VkExternalImageFormatPropertiesNV (already declared)
DIAG: *** Emitting command decl for vkGetPhysicalDeviceExternalImageFormatPropertiesNV
DIAG: Aligning parameter physicalDevice to column 48
DIAG: Adjust length of parameter decl from 20 to 48 :     VkPhysicalDevice                            
DIAG: Aligning parameter format to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkFormat                                    
DIAG: Aligning parameter type to column 48
DIAG: Adjust length of parameter decl from 15 to 48 :     VkImageType                                 
DIAG: Aligning parameter tiling to column 48
DIAG: Adjust length of parameter decl from 17 to 48 :     VkImageTiling                               
DIAG: Aligning parameter usage to column 48
DIAG: Adjust length of parameter decl from 21 to 48 :     VkImageUsageFlags                           
DIAG: Aligning parameter flags to column 48
DIAG: Adjust length of parameter decl from 22 to 48 :     VkImageCreateFlags                          
DIAG: Aligning parameter externalHandleType to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     VkExternalMemoryHandleTypeFlagsNV           
DIAG: Aligning parameter pExternalImageFormatProperties to column 48
DIAG: Adjust length of parameter decl from 38 to 48 :     VkExternalImageFormatPropertiesNV*          
DIAG: *** PASS 2: Generating interface for VK_NV_external_memory
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Emitting type decl for VkExternalMemoryImageCreateInfoNV
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Emitting type decl for VkExportMemoryAllocateInfoNV
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
DIAG: *** PASS 2: Generating interface for VK_NV_external_memory_win32
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Generating required dependent <type> HANDLE
DIAG: *** Generating required dependent type windows.h
DIAG: *** Skipping type windows.h (already declared)
DIAG: *** Emitting type decl for HANDLE
DIAG: *** Emitting type decl for VkImportMemoryWin32HandleInfoNV
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> SECURITY_ATTRIBUTES
DIAG: *** Generating required dependent type windows.h
DIAG: *** Skipping type windows.h (already declared)
DIAG: *** Emitting type decl for SECURITY_ATTRIBUTES
DIAG: *** Generating required dependent <type> DWORD
DIAG: *** Generating required dependent type windows.h
DIAG: *** Skipping type windows.h (already declared)
DIAG: *** Emitting type decl for DWORD
DIAG: *** Emitting type decl for VkExportMemoryWin32HandleInfoNV
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV
DIAG: *** Generating required parameter type VkResult
DIAG: *** Skipping type VkResult (already declared)
DIAG: *** Generating required parameter type VkDevice
DIAG: *** Skipping type VkDevice (already declared)
DIAG: *** Generating required parameter type VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required parameter type VkExternalMemoryHandleTypeFlagsNV
DIAG: *** Skipping type VkExternalMemoryHandleTypeFlagsNV (already declared)
DIAG: *** Generating required parameter type HANDLE
DIAG: *** Skipping type HANDLE (already declared)
DIAG: *** Emitting command decl for vkGetMemoryWin32HandleNV
DIAG: Aligning parameter device to column 48
DIAG: Adjust length of parameter decl from 12 to 48 :     VkDevice                                    
DIAG: Aligning parameter memory to column 48
DIAG: Adjust length of parameter decl from 18 to 48 :     VkDeviceMemory                              
DIAG: Aligning parameter handleType to column 48
DIAG: Adjust length of parameter decl from 37 to 48 :     VkExternalMemoryHandleTypeFlagsNV           
DIAG: Aligning parameter pHandle to column 48
DIAG: Adjust length of parameter decl from 11 to 48 :     HANDLE*                                     
DIAG: *** PASS 2: Generating interface for VK_NV_win32_keyed_mutex
DIAG: *** Generating required dependent <type> VkStructureType
DIAG: *** Skipping type VkStructureType (already declared)
DIAG: *** Generating required dependent <type> void
DIAG: *** Skipping type void (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> uint32_t
DIAG: *** Skipping type uint32_t (already declared)
DIAG: *** Generating required dependent <type> VkDeviceMemory
DIAG: *** Skipping type VkDeviceMemory (already declared)
DIAG: *** Generating required dependent <type> uint64_t
DIAG: *** Skipping type uint64_t (already declared)
DIAG: *** Emitting type decl for VkWin32KeyedMutexAcquireReleaseInfoNV
DIAG: *** Emitting enum decl for VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION
DIAG: *** Emitting enum decl for VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME
DIAG: *** Emitting enum decl for VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV
