// Copyright 2015-2022 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//

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

#ifndef VULKAN_HPP
#define VULKAN_HPP

#if defined(_MSVC_LANG)
#	define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
#else
#	define VULKAN_HPP_CPLUSPLUS __cplusplus
#endif

#if 201703L < VULKAN_HPP_CPLUSPLUS
#	define VULKAN_HPP_CPP_VERSION 20
#elif 201402L < VULKAN_HPP_CPLUSPLUS
#	define VULKAN_HPP_CPP_VERSION 17
#elif 201103L < VULKAN_HPP_CPLUSPLUS
#	define VULKAN_HPP_CPP_VERSION 14
#elif 199711L < VULKAN_HPP_CPLUSPLUS
#	define VULKAN_HPP_CPP_VERSION 11
#else
#	error "vulkan.hpp needs at least c++ standard version 11"
#endif

#include <vulkan/vulkan.h>
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <sstream>
#include <string>
#include <system_error>
#include <tuple>
#include <type_traits>
#if 17 <= VULKAN_HPP_CPP_VERSION
#	include <string_view>
#endif

#if defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
#	if !defined(VULKAN_HPP_NO_SMART_HANDLE)
#		define VULKAN_HPP_NO_SMART_HANDLE
#	endif
#else
#	include <memory>
#	include <vector>
#endif

#if defined(VULKAN_HPP_NO_CONSTRUCTORS)
#	if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
#		define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
#	endif
#	if !defined(VULKAN_HPP_NO_UNION_CONSTRUCTORS)
#		define VULKAN_HPP_NO_UNION_CONSTRUCTORS
#	endif
#endif

#if defined(VULKAN_HPP_NO_SETTERS)
#	if !defined(VULKAN_HPP_NO_STRUCT_SETTERS)
#		define VULKAN_HPP_NO_STRUCT_SETTERS
#	endif
#	if !defined(VULKAN_HPP_NO_UNION_SETTERS)
#		define VULKAN_HPP_NO_UNION_SETTERS
#	endif
#endif

#if !defined(VULKAN_HPP_ASSERT)
#	include <cassert>
#	define VULKAN_HPP_ASSERT assert
#endif

#if !defined(VULKAN_HPP_ASSERT_ON_RESULT)
#	define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
#endif

#if !defined(VULKAN_HPP_STATIC_ASSERT)
#	define VULKAN_HPP_STATIC_ASSERT static_assert
#endif

#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
#	define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
#endif

#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
#		include <dlfcn.h>
#	elif defined(_WIN32)
typedef struct HINSTANCE__ *HINSTANCE;
#		if defined(_WIN64)
typedef int64_t(__stdcall *FARPROC)();
#		else
typedef int(__stdcall *FARPROC)();
#		endif
extern "C" __declspec(dllimport) HINSTANCE __stdcall LoadLibraryA(char const *lpLibFileName);
extern "C" __declspec(dllimport) int __stdcall FreeLibrary(HINSTANCE hLibModule);
extern "C" __declspec(dllimport) FARPROC __stdcall GetProcAddress(HINSTANCE hModule, const char *lpProcName);
#	endif
#endif

#if !defined(__has_include)
#	define __has_include(x) false
#endif

#if(201711 <= __cpp_impl_three_way_comparison) && __has_include(<compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
#	define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
#endif
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
#	include <compare>
#endif

#if(201803 <= __cpp_lib_span)
#	define VULKAN_HPP_SUPPORT_SPAN
#	include <span>
#endif

static_assert(VK_HEADER_VERSION == 211, "Wrong VK_HEADER_VERSION!");

// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
#if(VK_USE_64_BIT_PTR_DEFINES == 1)
#	if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
#		define VULKAN_HPP_TYPESAFE_CONVERSION
#	endif
#endif

// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
// which is an expression in a constructor initializer list.
#if defined(major)
#	undef major
#endif
#if defined(minor)
#	undef minor
#endif

// Windows defines MemoryBarrier which is deprecated and collides
// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
#if defined(MemoryBarrier)
#	undef MemoryBarrier
#endif

#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
#	if defined(__clang__)
#		if __has_feature(cxx_unrestricted_unions)
#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
#		endif
#	elif defined(__GNUC__)
#		define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#		if 40600 <= GCC_VERSION
#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
#		endif
#	elif defined(_MSC_VER)
#		if 1900 <= _MSC_VER
#			define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
#		endif
#	endif
#endif

#if !defined(VULKAN_HPP_INLINE)
#	if defined(__clang__)
#		if __has_attribute(always_inline)
#			define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
#		else
#			define VULKAN_HPP_INLINE inline
#		endif
#	elif defined(__GNUC__)
#		define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
#	elif defined(_MSC_VER)
#		define VULKAN_HPP_INLINE inline
#	else
#		define VULKAN_HPP_INLINE inline
#	endif
#endif

#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
#	define VULKAN_HPP_TYPESAFE_EXPLICIT
#else
#	define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
#endif

#if defined(__cpp_constexpr)
#	define VULKAN_HPP_CONSTEXPR constexpr
#	if __cpp_constexpr >= 201304
#		define VULKAN_HPP_CONSTEXPR_14 constexpr
#	else
#		define VULKAN_HPP_CONSTEXPR_14
#	endif
#	define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
#else
#	define VULKAN_HPP_CONSTEXPR
#	define VULKAN_HPP_CONSTEXPR_14
#	define VULKAN_HPP_CONST_OR_CONSTEXPR const
#endif

#if !defined(VULKAN_HPP_NOEXCEPT)
#	if defined(_MSC_VER) && (_MSC_VER <= 1800)
#		define VULKAN_HPP_NOEXCEPT
#	else
#		define VULKAN_HPP_NOEXCEPT noexcept
#		define VULKAN_HPP_HAS_NOEXCEPT 1
#		if defined(VULKAN_HPP_NO_EXCEPTIONS)
#			define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
#		else
#			define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
#		endif
#	endif
#endif

#if 14 <= VULKAN_HPP_CPP_VERSION
#	define VULKAN_HPP_DEPRECATED(msg) [[deprecated(msg)]]
#else
#	define VULKAN_HPP_DEPRECATED(msg)
#endif

#if(17 <= VULKAN_HPP_CPP_VERSION) && !defined(VULKAN_HPP_NO_NODISCARD_WARNINGS)
#	define VULKAN_HPP_NODISCARD [[nodiscard]]
#	if defined(VULKAN_HPP_NO_EXCEPTIONS)
#		define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
#	else
#		define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
#	endif
#else
#	define VULKAN_HPP_NODISCARD
#	define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
#endif

#if !defined(VULKAN_HPP_NAMESPACE)
#	define VULKAN_HPP_NAMESPACE vk
#endif

#define VULKAN_HPP_STRINGIFY2(text) #text
#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)

namespace VULKAN_HPP_NAMESPACE {
#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
template<typename T>
class ArrayProxy
{
public:
	VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
	    : m_count(0),
	      m_ptr(nullptr)
	{
	}

	VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
	    : m_count(0),
	      m_ptr(nullptr)
	{
	}

	ArrayProxy(T &value) VULKAN_HPP_NOEXCEPT
	    : m_count(1),
	      m_ptr(&value)
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxy(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
	    : m_count(1),
	      m_ptr(&value)
	{
	}

	ArrayProxy(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
	    : m_count(count),
	      m_ptr(ptr)
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxy(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
	    : m_count(count),
	      m_ptr(ptr)
	{
	}

#	if __GNUC__ >= 9
#		pragma GCC diagnostic push
#		pragma GCC diagnostic ignored "-Winit-list-lifetime"
#	endif

	ArrayProxy(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	ArrayProxy(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

#	if __GNUC__ >= 9
#		pragma GCC diagnostic pop
#	endif

	// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
	// convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
	template<typename V,
	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
	ArrayProxy(V const &v) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(v.size())),
	      m_ptr(v.data())
	{
	}

	template<typename V,
	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
	ArrayProxy(V &v) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(v.size())),
	      m_ptr(v.data())
	{
	}

	const T *begin() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}

	const T *end() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr + m_count;
	}

	const T &front() const VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_count && m_ptr);
		return *m_ptr;
	}

	const T &back() const VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_count && m_ptr);
		return *(m_ptr + m_count - 1);
	}

	bool empty() const VULKAN_HPP_NOEXCEPT
	{
		return (m_count == 0);
	}

	uint32_t size() const VULKAN_HPP_NOEXCEPT
	{
		return m_count;
	}

	T *data() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}

private:
	uint32_t m_count;
	T *m_ptr;
};

template<typename T>
class ArrayProxyNoTemporaries
{
public:
	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
	    : m_count(0),
	      m_ptr(nullptr)
	{
	}

	VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries(std::nullptr_t) VULKAN_HPP_NOEXCEPT
	    : m_count(0),
	      m_ptr(nullptr)
	{
	}

	ArrayProxyNoTemporaries(T &value) VULKAN_HPP_NOEXCEPT
	    : m_count(1),
	      m_ptr(&value)
	{
	}

	template<typename V>
	ArrayProxyNoTemporaries(V &&value) = delete;

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
	    : m_count(1),
	      m_ptr(&value)
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(typename std::remove_const<T>::type &&value) = delete;

	ArrayProxyNoTemporaries(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
	    : m_count(count),
	      m_ptr(ptr)
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
	    : m_count(count),
	      m_ptr(ptr)
	{
	}

	ArrayProxyNoTemporaries(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	ArrayProxyNoTemporaries(std::initializer_list<T> const &&list) = delete;

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &&list) = delete;

	ArrayProxyNoTemporaries(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	ArrayProxyNoTemporaries(std::initializer_list<T> &&list) = delete;

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(list.size())),
	      m_ptr(list.begin())
	{
	}

	template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
	ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &&list) = delete;

	// Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
	// convertible to size_t.
	template<typename V,
	         typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
	                                 std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
	ArrayProxyNoTemporaries(V &v) VULKAN_HPP_NOEXCEPT
	    : m_count(static_cast<uint32_t>(v.size())),
	      m_ptr(v.data())
	{
	}

	const T *begin() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}

	const T *end() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr + m_count;
	}

	const T &front() const VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_count && m_ptr);
		return *m_ptr;
	}

	const T &back() const VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_count && m_ptr);
		return *(m_ptr + m_count - 1);
	}

	bool empty() const VULKAN_HPP_NOEXCEPT
	{
		return (m_count == 0);
	}

	uint32_t size() const VULKAN_HPP_NOEXCEPT
	{
		return m_count;
	}

	T *data() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}

private:
	uint32_t m_count;
	T *m_ptr;
};
#endif

template<typename T, size_t N>
class ArrayWrapper1D : public std::array<T, N>
{
public:
	VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}

	VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array<T, N> const &data) VULKAN_HPP_NOEXCEPT : std::array<T, N>(data) {}

#if(VK_USE_64_BIT_PTR_DEFINES == 0)
	// on 32 bit compiles, needs overloads on index type int to resolve ambiguities
	VULKAN_HPP_CONSTEXPR T const &operator[](int index) const VULKAN_HPP_NOEXCEPT
	{
		return std::array<T, N>::operator[](index);
	}

	T &operator[](int index) VULKAN_HPP_NOEXCEPT
	{
		return std::array<T, N>::operator[](index);
	}
#endif

	operator T const *() const VULKAN_HPP_NOEXCEPT
	{
		return this->data();
	}

	operator T *() VULKAN_HPP_NOEXCEPT
	{
		return this->data();
	}

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	operator std::string() const
	{
		return std::string(this->data());
	}

#if 17 <= VULKAN_HPP_CPP_VERSION
	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	operator std::string_view() const
	{
		return std::string_view(this->data());
	}
#endif

#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	std::strong_ordering operator<=>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) <=> *static_cast<std::array<char, N> const *>(&rhs);
	}
#else
	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator<(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) < *static_cast<std::array<char, N> const *>(&rhs);
	}

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator<=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) <= *static_cast<std::array<char, N> const *>(&rhs);
	}

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) > *static_cast<std::array<char, N> const *>(&rhs);
	}

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator>=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) >= *static_cast<std::array<char, N> const *>(&rhs);
	}
#endif

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator==(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) == *static_cast<std::array<char, N> const *>(&rhs);
	}

	template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
	bool operator!=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return *static_cast<std::array<char, N> const *>(this) != *static_cast<std::array<char, N> const *>(&rhs);
	}
};

// specialization of relational operators between std::string and arrays of chars
template<size_t N>
bool operator<(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs < rhs.data();
}

template<size_t N>
bool operator<=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs <= rhs.data();
}

template<size_t N>
bool operator>(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs > rhs.data();
}

template<size_t N>
bool operator>=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs >= rhs.data();
}

template<size_t N>
bool operator==(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs == rhs.data();
}

template<size_t N>
bool operator!=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
{
	return lhs != rhs.data();
}

template<typename T, size_t N, size_t M>
class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
{
public:
	VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}

	VULKAN_HPP_CONSTEXPR ArrayWrapper2D(std::array<std::array<T, M>, N> const &data) VULKAN_HPP_NOEXCEPT
	    : std::array<ArrayWrapper1D<T, M>, N>(*reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>(&data))
	{
	}
};

template<typename FlagBitsType>
struct FlagTraits
{
};

template<typename BitType>
class Flags
{
public:
	using MaskType = typename std::underlying_type<BitType>::type;

	// constructors
	VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask(0) {}

	VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT : m_mask(static_cast<MaskType>(bit)) {}

	VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;

	VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags) VULKAN_HPP_NOEXCEPT : m_mask(flags) {}

	// relational operators
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
	auto operator<=>(Flags<BitType> const &) const = default;
#else
	VULKAN_HPP_CONSTEXPR bool operator<(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask < rhs.m_mask;
	}

	VULKAN_HPP_CONSTEXPR bool operator<=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask <= rhs.m_mask;
	}

	VULKAN_HPP_CONSTEXPR bool operator>(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask > rhs.m_mask;
	}

	VULKAN_HPP_CONSTEXPR bool operator>=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask >= rhs.m_mask;
	}

	VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask == rhs.m_mask;
	}

	VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return m_mask != rhs.m_mask;
	}
#endif

	// logical operator
	VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
	{
		return !m_mask;
	}

	// bitwise operators
	VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return Flags<BitType>(m_mask & rhs.m_mask);
	}

	VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return Flags<BitType>(m_mask | rhs.m_mask);
	}

	VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
	{
		return Flags<BitType>(m_mask ^ rhs.m_mask);
	}

	VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
	{
		return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags);
	}

	// assignment operators
	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;

	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator|=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
	{
		m_mask |= rhs.m_mask;
		return *this;
	}

	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator&=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
	{
		m_mask &= rhs.m_mask;
		return *this;
	}

	VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator^=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
	{
		m_mask ^= rhs.m_mask;
		return *this;
	}

	// cast operators
	explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
	{
		return !!m_mask;
	}

	explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
	{
		return m_mask;
	}

#if defined(VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC)
public:
#else
private:
#endif
	MaskType m_mask;
};

#if !defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
// relational operators only needed for pre C++20
template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator<(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator>(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator<=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator>=(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator>(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator<(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator>=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator<=(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator==(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator!=(bit);
}
#endif

// bitwise operators
template<typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator&(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator|(bit);
}

template<typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
{
	return flags.operator^(bit);
}

template<typename RefType>
class Optional
{
public:
	Optional(RefType &reference) VULKAN_HPP_NOEXCEPT
	{
		m_ptr = &reference;
	}
	Optional(RefType *ptr) VULKAN_HPP_NOEXCEPT
	{
		m_ptr = ptr;
	}
	Optional(std::nullptr_t) VULKAN_HPP_NOEXCEPT
	{
		m_ptr = nullptr;
	}

	operator RefType *() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}
	RefType const *operator->() const VULKAN_HPP_NOEXCEPT
	{
		return m_ptr;
	}
	explicit operator bool() const VULKAN_HPP_NOEXCEPT
	{
		return !!m_ptr;
	}

private:
	RefType *m_ptr;
};

template<typename X, typename Y>
struct StructExtends
{
	enum
	{
		value = false
	};
};

template<typename Type, class...>
struct IsPartOfStructureChain
{
	static const bool valid = false;
};

template<typename Type, typename Head, typename... Tail>
struct IsPartOfStructureChain<Type, Head, Tail...>
{
	static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
};

template<size_t Index, typename T, typename... ChainElements>
struct StructureChainContains
{
	static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
	                          StructureChainContains<Index - 1, T, ChainElements...>::value;
};

template<typename T, typename... ChainElements>
struct StructureChainContains<0, T, ChainElements...>
{
	static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
};

template<size_t Index, typename... ChainElements>
struct StructureChainValidation
{
	using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
	static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
	                          (TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value) &&
	                          StructureChainValidation<Index - 1, ChainElements...>::valid;
};

template<typename... ChainElements>
struct StructureChainValidation<0, ChainElements...>
{
	static const bool valid = true;
};

template<typename... ChainElements>
class StructureChain : public std::tuple<ChainElements...>
{
public:
	StructureChain() VULKAN_HPP_NOEXCEPT
	{
		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
		link<sizeof...(ChainElements) - 1>();
	}

	StructureChain(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(rhs)
	{
		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
		link(&std::get<0>(*this),
		     &std::get<0>(rhs),
		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
	}

	StructureChain(StructureChain &&rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(std::forward<std::tuple<ChainElements...>>(rhs))
	{
		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
		link(&std::get<0>(*this),
		     &std::get<0>(rhs),
		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
	}

	StructureChain(ChainElements const &... elems) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(elems...)
	{
		static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
		link<sizeof...(ChainElements) - 1>();
	}

	StructureChain &operator=(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
	{
		std::tuple<ChainElements...>::operator=(rhs);
		link(&std::get<0>(*this),
		     &std::get<0>(rhs),
		     reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
		     reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
		return *this;
	}

	StructureChain &operator=(StructureChain &&rhs) = delete;

	template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
	T &get() VULKAN_HPP_NOEXCEPT
	{
		return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> &>(*this));
	}

	template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
	T const &get() const VULKAN_HPP_NOEXCEPT
	{
		return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> const &>(*this));
	}

	template<typename T0, typename T1, typename... Ts>
	std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
	{
		return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
	}

	template<typename T0, typename T1, typename... Ts>
	std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
	{
		return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
	}

	template<typename ClassType, size_t Which = 0>
	typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && (Which == 0), bool>::type
	isLinked() const VULKAN_HPP_NOEXCEPT
	{
		return true;
	}

	template<typename ClassType, size_t Which = 0>
	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), bool>::type
	isLinked() const VULKAN_HPP_NOEXCEPT
	{
		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
		return isLinked(reinterpret_cast<VkBaseInStructure const *>(&get<ClassType, Which>()));
	}

	template<typename ClassType, size_t Which = 0>
	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
	relink() VULKAN_HPP_NOEXCEPT
	{
		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!");
		auto pNext = reinterpret_cast<VkBaseInStructure *>(&get<ClassType, Which>());
		VULKAN_HPP_ASSERT(!isLinked(pNext));
		auto &headElement = std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this));
		pNext->pNext = reinterpret_cast<VkBaseInStructure const *>(headElement.pNext);
		headElement.pNext = pNext;
	}

	template<typename ClassType, size_t Which = 0>
	typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
	unlink() VULKAN_HPP_NOEXCEPT
	{
		static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
		unlink(reinterpret_cast<VkBaseOutStructure const *>(&get<ClassType, Which>()));
	}

private:
	template<int Index, typename T, int Which, typename, class First, class... Types>
	struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
	{
	};

	template<int Index, typename T, int Which, class First, class... Types>
	struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
	    : ChainElementIndex<Index + 1, T, Which, void, Types...>
	{
	};

	template<int Index, typename T, int Which, class First, class... Types>
	struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
	    : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
	{
	};

	template<int Index, typename T, class First, class... Types>
	struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
	    : std::integral_constant<int, Index>
	{
	};

	bool isLinked(VkBaseInStructure const *pNext) const VULKAN_HPP_NOEXCEPT
	{
		VkBaseInStructure const *elementPtr =
		    reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(static_cast<std::tuple<ChainElements...> const &>(*this)));
		while(elementPtr)
		{
			if(elementPtr->pNext == pNext)
			{
				return true;
			}
			elementPtr = elementPtr->pNext;
		}
		return false;
	}

	template<size_t Index>
	typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
	{
		auto &x = std::get<Index - 1>(static_cast<std::tuple<ChainElements...> &>(*this));
		x.pNext = &std::get<Index>(static_cast<std::tuple<ChainElements...> &>(*this));
		link<Index - 1>();
	}

	template<size_t Index>
	typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
	{
	}

	void link(void *dstBase, void const *srcBase, VkBaseOutStructure *dst, VkBaseInStructure const *src)
	{
		while(src->pNext)
		{
			std::ptrdiff_t offset = reinterpret_cast<char const *>(src->pNext) - reinterpret_cast<char const *>(srcBase);
			dst->pNext = reinterpret_cast<VkBaseOutStructure *>(reinterpret_cast<char *>(dstBase) + offset);
			dst = dst->pNext;
			src = src->pNext;
		}
		dst->pNext = nullptr;
	}

	void unlink(VkBaseOutStructure const *pNext) VULKAN_HPP_NOEXCEPT
	{
		VkBaseOutStructure *elementPtr = reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this)));
		while(elementPtr && (elementPtr->pNext != pNext))
		{
			elementPtr = elementPtr->pNext;
		}
		if(elementPtr)
		{
			elementPtr->pNext = pNext->pNext;
		}
		else
		{
			VULKAN_HPP_ASSERT(false);  // fires, if the ClassType member has already been unlinked !
		}
	}
};

#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
template<typename Type, typename Dispatch>
class UniqueHandleTraits;

template<typename Type, typename Dispatch>
class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
{
private:
	using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;

public:
	using element_type = Type;

	UniqueHandle()
	    : Deleter()
	    , m_value()
	{}

	explicit UniqueHandle(Type const &value, Deleter const &deleter = Deleter()) VULKAN_HPP_NOEXCEPT
	    : Deleter(deleter),
	      m_value(value)
	{
	}

	UniqueHandle(UniqueHandle const &) = delete;

	UniqueHandle(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
	    : Deleter(std::move(static_cast<Deleter &>(other))),
	      m_value(other.release())
	{
	}

	~UniqueHandle() VULKAN_HPP_NOEXCEPT
	{
		if(m_value)
		{
			this->destroy(m_value);
		}
	}

	UniqueHandle &operator=(UniqueHandle const &) = delete;

	UniqueHandle &operator=(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
	{
		reset(other.release());
		*static_cast<Deleter *>(this) = std::move(static_cast<Deleter &>(other));
		return *this;
	}

	explicit operator bool() const VULKAN_HPP_NOEXCEPT
	{
		return m_value.operator bool();
	}

	Type const *operator->() const VULKAN_HPP_NOEXCEPT
	{
		return &m_value;
	}

	Type *operator->() VULKAN_HPP_NOEXCEPT
	{
		return &m_value;
	}

	Type const &operator*() const VULKAN_HPP_NOEXCEPT
	{
		return m_value;
	}

	Type &operator*() VULKAN_HPP_NOEXCEPT
	{
		return m_value;
	}

	const Type &get() const VULKAN_HPP_NOEXCEPT
	{
		return m_value;
	}

	Type &get() VULKAN_HPP_NOEXCEPT
	{
		return m_value;
	}

	void reset(Type const &value = Type()) VULKAN_HPP_NOEXCEPT
	{
		if(m_value != value)
		{
			if(m_value)
			{
				this->destroy(m_value);
			}
			m_value = value;
		}
	}

	Type release() VULKAN_HPP_NOEXCEPT
	{
		Type value = m_value;
		m_value = nullptr;
		return value;
	}

	void swap(UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
	{
		std::swap(m_value, rhs.m_value);
		std::swap(static_cast<Deleter &>(*this), static_cast<Deleter &>(rhs));
	}

private:
	Type m_value;
};

template<typename UniqueType>
VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw(std::vector<UniqueType> const &handles)
{
	std::vector<typename UniqueType::element_type> newBuffer(handles.size());
	std::transform(handles.begin(), handles.end(), newBuffer.begin(), [](UniqueType const &handle) { return handle.get(); });
	return newBuffer;
}

template<typename Type, typename Dispatch>
VULKAN_HPP_INLINE void swap(UniqueHandle<Type, Dispatch> &lhs, UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
{
	lhs.swap(rhs);
}
#endif

class DispatchLoaderBase
{
public:
	DispatchLoaderBase() = default;
	DispatchLoaderBase(std::nullptr_t)
#if !defined(NDEBUG)
	    : m_valid(false)
#endif
	{
	}

#if !defined(NDEBUG)
	size_t getVkHeaderVersion() const
	{
		VULKAN_HPP_ASSERT(m_valid);
		return vkHeaderVersion;
	}

private:
	size_t vkHeaderVersion = VK_HEADER_VERSION;
	bool m_valid = true;
#endif
};

#if !defined(VK_NO_PROTOTYPES)
class DispatchLoaderStatic : public DispatchLoaderBase
{
public:
	//=== VK_VERSION_1_0 ===

	VkResult
	vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateInstance(pCreateInfo, pAllocator, pInstance);
	}

	void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyInstance(instance, pAllocator);
	}

	VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
	}

	void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
	}

	void
	vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
	}

	VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
	                                                  VkFormat format,
	                                                  VkImageType type,
	                                                  VkImageTiling tiling,
	                                                  VkImageUsageFlags usage,
	                                                  VkImageCreateFlags flags,
	                                                  VkImageFormatProperties *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
	}

	void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
	}

	void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
	                                              uint32_t *pQueueFamilyPropertyCount,
	                                              VkQueueFamilyProperties *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
	}

	void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
	}

	PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetInstanceProcAddr(instance, pName);
	}

	PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceProcAddr(device, pName);
	}

	VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
	                        const VkDeviceCreateInfo *pCreateInfo,
	                        const VkAllocationCallbacks *pAllocator,
	                        VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
	}

	void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDevice(device, pAllocator);
	}

	VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName,
	                                                uint32_t *pPropertyCount,
	                                                VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
	}

	VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
	                                              const char *pLayerName,
	                                              uint32_t *pPropertyCount,
	                                              VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
	}

	VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
	}

	VkResult
	vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
	}

	void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
	}

	VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueSubmit(queue, submitCount, pSubmits, fence);
	}

	VkResult vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueWaitIdle(queue);
	}

	VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDeviceWaitIdle(device);
	}

	VkResult vkAllocateMemory(VkDevice device,
	                          const VkMemoryAllocateInfo *pAllocateInfo,
	                          const VkAllocationCallbacks *pAllocator,
	                          VkDeviceMemory *pMemory) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
	}

	void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkFreeMemory(device, memory, pAllocator);
	}

	VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkMapMemory(device, memory, offset, size, flags, ppData);
	}

	void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUnmapMemory(device, memory);
	}

	VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
	}

	VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
	}

	void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
	}

	VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindBufferMemory(device, buffer, memory, memoryOffset);
	}

	VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindImageMemory(device, image, memory, memoryOffset);
	}

	void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
	}

	void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
	}

	void vkGetImageSparseMemoryRequirements(VkDevice device,
	                                        VkImage image,
	                                        uint32_t *pSparseMemoryRequirementCount,
	                                        VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
	}

	void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,
	                                                    VkFormat format,
	                                                    VkImageType type,
	                                                    VkSampleCountFlagBits samples,
	                                                    VkImageUsageFlags usage,
	                                                    VkImageTiling tiling,
	                                                    uint32_t *pPropertyCount,
	                                                    VkSparseImageFormatProperties *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
	}

	VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
	}

	VkResult vkCreateFence(VkDevice device,
	                       const VkFenceCreateInfo *pCreateInfo,
	                       const VkAllocationCallbacks *pAllocator,
	                       VkFence *pFence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateFence(device, pCreateInfo, pAllocator, pFence);
	}

	void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyFence(device, fence, pAllocator);
	}

	VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetFences(device, fenceCount, pFences);
	}

	VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetFenceStatus(device, fence);
	}

	VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
	}

	VkResult vkCreateSemaphore(VkDevice device,
	                           const VkSemaphoreCreateInfo *pCreateInfo,
	                           const VkAllocationCallbacks *pAllocator,
	                           VkSemaphore *pSemaphore) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
	}

	void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySemaphore(device, semaphore, pAllocator);
	}

	VkResult vkCreateEvent(VkDevice device,
	                       const VkEventCreateInfo *pCreateInfo,
	                       const VkAllocationCallbacks *pAllocator,
	                       VkEvent *pEvent) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
	}

	void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyEvent(device, event, pAllocator);
	}

	VkResult vkGetEventStatus(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetEventStatus(device, event);
	}

	VkResult vkSetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetEvent(device, event);
	}

	VkResult vkResetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetEvent(device, event);
	}

	VkResult vkCreateQueryPool(VkDevice device,
	                           const VkQueryPoolCreateInfo *pCreateInfo,
	                           const VkAllocationCallbacks *pAllocator,
	                           VkQueryPool *pQueryPool) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
	}

	void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyQueryPool(device, queryPool, pAllocator);
	}

	VkResult vkGetQueryPoolResults(VkDevice device,
	                               VkQueryPool queryPool,
	                               uint32_t firstQuery,
	                               uint32_t queryCount,
	                               size_t dataSize,
	                               void *pData,
	                               VkDeviceSize stride,
	                               VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
	}

	VkResult vkCreateBuffer(VkDevice device,
	                        const VkBufferCreateInfo *pCreateInfo,
	                        const VkAllocationCallbacks *pAllocator,
	                        VkBuffer *pBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
	}

	void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyBuffer(device, buffer, pAllocator);
	}

	VkResult vkCreateBufferView(VkDevice device,
	                            const VkBufferViewCreateInfo *pCreateInfo,
	                            const VkAllocationCallbacks *pAllocator,
	                            VkBufferView *pView) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
	}

	void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyBufferView(device, bufferView, pAllocator);
	}

	VkResult vkCreateImage(VkDevice device,
	                       const VkImageCreateInfo *pCreateInfo,
	                       const VkAllocationCallbacks *pAllocator,
	                       VkImage *pImage) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateImage(device, pCreateInfo, pAllocator, pImage);
	}

	void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyImage(device, image, pAllocator);
	}

	void vkGetImageSubresourceLayout(VkDevice device,
	                                 VkImage image,
	                                 const VkImageSubresource *pSubresource,
	                                 VkSubresourceLayout *pLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
	}

	VkResult vkCreateImageView(VkDevice device,
	                           const VkImageViewCreateInfo *pCreateInfo,
	                           const VkAllocationCallbacks *pAllocator,
	                           VkImageView *pView) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateImageView(device, pCreateInfo, pAllocator, pView);
	}

	void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyImageView(device, imageView, pAllocator);
	}

	VkResult vkCreateShaderModule(VkDevice device,
	                              const VkShaderModuleCreateInfo *pCreateInfo,
	                              const VkAllocationCallbacks *pAllocator,
	                              VkShaderModule *pShaderModule) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
	}

	void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyShaderModule(device, shaderModule, pAllocator);
	}

	VkResult vkCreatePipelineCache(VkDevice device,
	                               const VkPipelineCacheCreateInfo *pCreateInfo,
	                               const VkAllocationCallbacks *pAllocator,
	                               VkPipelineCache *pPipelineCache) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
	}

	void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyPipelineCache(device, pipelineCache, pAllocator);
	}

	VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
	}

	VkResult
	vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
	}

	VkResult vkCreateGraphicsPipelines(VkDevice device,
	                                   VkPipelineCache pipelineCache,
	                                   uint32_t createInfoCount,
	                                   const VkGraphicsPipelineCreateInfo *pCreateInfos,
	                                   const VkAllocationCallbacks *pAllocator,
	                                   VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
	}

	VkResult vkCreateComputePipelines(VkDevice device,
	                                  VkPipelineCache pipelineCache,
	                                  uint32_t createInfoCount,
	                                  const VkComputePipelineCreateInfo *pCreateInfos,
	                                  const VkAllocationCallbacks *pAllocator,
	                                  VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
	}

	void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyPipeline(device, pipeline, pAllocator);
	}

	VkResult vkCreatePipelineLayout(VkDevice device,
	                                const VkPipelineLayoutCreateInfo *pCreateInfo,
	                                const VkAllocationCallbacks *pAllocator,
	                                VkPipelineLayout *pPipelineLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
	}

	void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
	}

	VkResult vkCreateSampler(VkDevice device,
	                         const VkSamplerCreateInfo *pCreateInfo,
	                         const VkAllocationCallbacks *pAllocator,
	                         VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
	}

	void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySampler(device, sampler, pAllocator);
	}

	VkResult vkCreateDescriptorSetLayout(VkDevice device,
	                                     const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
	                                     const VkAllocationCallbacks *pAllocator,
	                                     VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
	}

	void vkDestroyDescriptorSetLayout(VkDevice device,
	                                  VkDescriptorSetLayout descriptorSetLayout,
	                                  const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
	}

	VkResult vkCreateDescriptorPool(VkDevice device,
	                                const VkDescriptorPoolCreateInfo *pCreateInfo,
	                                const VkAllocationCallbacks *pAllocator,
	                                VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
	}

	void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
	}

	VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetDescriptorPool(device, descriptorPool, flags);
	}

	VkResult vkAllocateDescriptorSets(VkDevice device,
	                                  const VkDescriptorSetAllocateInfo *pAllocateInfo,
	                                  VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
	}

	VkResult vkFreeDescriptorSets(VkDevice device,
	                              VkDescriptorPool descriptorPool,
	                              uint32_t descriptorSetCount,
	                              const VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
	}

	void vkUpdateDescriptorSets(VkDevice device,
	                            uint32_t descriptorWriteCount,
	                            const VkWriteDescriptorSet *pDescriptorWrites,
	                            uint32_t descriptorCopyCount,
	                            const VkCopyDescriptorSet *pDescriptorCopies) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
	}

	VkResult vkCreateFramebuffer(VkDevice device,
	                             const VkFramebufferCreateInfo *pCreateInfo,
	                             const VkAllocationCallbacks *pAllocator,
	                             VkFramebuffer *pFramebuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
	}

	void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyFramebuffer(device, framebuffer, pAllocator);
	}

	VkResult vkCreateRenderPass(VkDevice device,
	                            const VkRenderPassCreateInfo *pCreateInfo,
	                            const VkAllocationCallbacks *pAllocator,
	                            VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
	}

	void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyRenderPass(device, renderPass, pAllocator);
	}

	void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRenderAreaGranularity(device, renderPass, pGranularity);
	}

	VkResult vkCreateCommandPool(VkDevice device,
	                             const VkCommandPoolCreateInfo *pCreateInfo,
	                             const VkAllocationCallbacks *pAllocator,
	                             VkCommandPool *pCommandPool) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
	}

	void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyCommandPool(device, commandPool, pAllocator);
	}

	VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetCommandPool(device, commandPool, flags);
	}

	VkResult vkAllocateCommandBuffers(VkDevice device,
	                                  const VkCommandBufferAllocateInfo *pAllocateInfo,
	                                  VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
	}

	void vkFreeCommandBuffers(VkDevice device,
	                          VkCommandPool commandPool,
	                          uint32_t commandBufferCount,
	                          const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
	}

	VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBeginCommandBuffer(commandBuffer, pBeginInfo);
	}

	VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEndCommandBuffer(commandBuffer);
	}

	VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetCommandBuffer(commandBuffer, flags);
	}

	void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
	}

	void
	vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
	}

	void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
	}

	void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetLineWidth(commandBuffer, lineWidth);
	}

	void vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
	                       float depthBiasConstantFactor,
	                       float depthBiasClamp,
	                       float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
	}

	void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetBlendConstants(commandBuffer, blendConstants);
	}

	void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
	}

	void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
	}

	void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
	}

	void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilReference(commandBuffer, faceMask, reference);
	}

	void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
	                             VkPipelineBindPoint pipelineBindPoint,
	                             VkPipelineLayout layout,
	                             uint32_t firstSet,
	                             uint32_t descriptorSetCount,
	                             const VkDescriptorSet *pDescriptorSets,
	                             uint32_t dynamicOffsetCount,
	                             const uint32_t *pDynamicOffsets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindDescriptorSets(
		    commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
	}

	void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
	}

	void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
	                            uint32_t firstBinding,
	                            uint32_t bindingCount,
	                            const VkBuffer *pBuffers,
	                            const VkDeviceSize *pOffsets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
	}

	void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
	}

	void vkCmdDrawIndexed(VkCommandBuffer commandBuffer,
	                      uint32_t indexCount,
	                      uint32_t instanceCount,
	                      uint32_t firstIndex,
	                      int32_t vertexOffset,
	                      uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
	}

	void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
	}

	void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
	}

	void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
	}

	void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDispatchIndirect(commandBuffer, buffer, offset);
	}

	void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
	}

	void vkCmdCopyImage(VkCommandBuffer commandBuffer,
	                    VkImage srcImage,
	                    VkImageLayout srcImageLayout,
	                    VkImage dstImage,
	                    VkImageLayout dstImageLayout,
	                    uint32_t regionCount,
	                    const VkImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
	}

	void vkCmdBlitImage(VkCommandBuffer commandBuffer,
	                    VkImage srcImage,
	                    VkImageLayout srcImageLayout,
	                    VkImage dstImage,
	                    VkImageLayout dstImageLayout,
	                    uint32_t regionCount,
	                    const VkImageBlit *pRegions,
	                    VkFilter filter) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
	}

	void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
	                            VkBuffer srcBuffer,
	                            VkImage dstImage,
	                            VkImageLayout dstImageLayout,
	                            uint32_t regionCount,
	                            const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
	}

	void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
	                            VkImage srcImage,
	                            VkImageLayout srcImageLayout,
	                            VkBuffer dstBuffer,
	                            uint32_t regionCount,
	                            const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
	}

	void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
	}

	void
	vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
	}

	void vkCmdClearColorImage(VkCommandBuffer commandBuffer,
	                          VkImage image,
	                          VkImageLayout imageLayout,
	                          const VkClearColorValue *pColor,
	                          uint32_t rangeCount,
	                          const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
	}

	void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
	                                 VkImage image,
	                                 VkImageLayout imageLayout,
	                                 const VkClearDepthStencilValue *pDepthStencil,
	                                 uint32_t rangeCount,
	                                 const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
	}

	void vkCmdClearAttachments(VkCommandBuffer commandBuffer,
	                           uint32_t attachmentCount,
	                           const VkClearAttachment *pAttachments,
	                           uint32_t rectCount,
	                           const VkClearRect *pRects) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
	}

	void vkCmdResolveImage(VkCommandBuffer commandBuffer,
	                       VkImage srcImage,
	                       VkImageLayout srcImageLayout,
	                       VkImage dstImage,
	                       VkImageLayout dstImageLayout,
	                       uint32_t regionCount,
	                       const VkImageResolve *pRegions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
	}

	void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetEvent(commandBuffer, event, stageMask);
	}

	void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResetEvent(commandBuffer, event, stageMask);
	}

	void vkCmdWaitEvents(VkCommandBuffer commandBuffer,
	                     uint32_t eventCount,
	                     const VkEvent *pEvents,
	                     VkPipelineStageFlags srcStageMask,
	                     VkPipelineStageFlags dstStageMask,
	                     uint32_t memoryBarrierCount,
	                     const VkMemoryBarrier *pMemoryBarriers,
	                     uint32_t bufferMemoryBarrierCount,
	                     const VkBufferMemoryBarrier *pBufferMemoryBarriers,
	                     uint32_t imageMemoryBarrierCount,
	                     const VkImageMemoryBarrier *pImageMemoryBarriers) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWaitEvents(commandBuffer,
		                         eventCount,
		                         pEvents,
		                         srcStageMask,
		                         dstStageMask,
		                         memoryBarrierCount,
		                         pMemoryBarriers,
		                         bufferMemoryBarrierCount,
		                         pBufferMemoryBarriers,
		                         imageMemoryBarrierCount,
		                         pImageMemoryBarriers);
	}

	void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer,
	                          VkPipelineStageFlags srcStageMask,
	                          VkPipelineStageFlags dstStageMask,
	                          VkDependencyFlags dependencyFlags,
	                          uint32_t memoryBarrierCount,
	                          const VkMemoryBarrier *pMemoryBarriers,
	                          uint32_t bufferMemoryBarrierCount,
	                          const VkBufferMemoryBarrier *pBufferMemoryBarriers,
	                          uint32_t imageMemoryBarrierCount,
	                          const VkImageMemoryBarrier *pImageMemoryBarriers) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPipelineBarrier(commandBuffer,
		                              srcStageMask,
		                              dstStageMask,
		                              dependencyFlags,
		                              memoryBarrierCount,
		                              pMemoryBarriers,
		                              bufferMemoryBarrierCount,
		                              pBufferMemoryBarriers,
		                              imageMemoryBarrierCount,
		                              pImageMemoryBarriers);
	}

	void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
	}

	void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndQuery(commandBuffer, queryPool, query);
	}

	void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
	}

	void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
	                         VkPipelineStageFlagBits pipelineStage,
	                         VkQueryPool queryPool,
	                         uint32_t query) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
	}

	void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
	                               VkQueryPool queryPool,
	                               uint32_t firstQuery,
	                               uint32_t queryCount,
	                               VkBuffer dstBuffer,
	                               VkDeviceSize dstOffset,
	                               VkDeviceSize stride,
	                               VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
	}

	void vkCmdPushConstants(VkCommandBuffer commandBuffer,
	                        VkPipelineLayout layout,
	                        VkShaderStageFlags stageFlags,
	                        uint32_t offset,
	                        uint32_t size,
	                        const void *pValues) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
	}

	void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
	                          const VkRenderPassBeginInfo *pRenderPassBegin,
	                          VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
	}

	void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdNextSubpass(commandBuffer, contents);
	}

	void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndRenderPass(commandBuffer);
	}

	void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
	}

	//=== VK_VERSION_1_1 ===

	VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumerateInstanceVersion(pApiVersion);
	}

	VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
	}

	VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindImageMemory2(device, bindInfoCount, pBindInfos);
	}

	void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,
	                                        uint32_t heapIndex,
	                                        uint32_t localDeviceIndex,
	                                        uint32_t remoteDeviceIndex,
	                                        VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
	}

	void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDeviceMask(commandBuffer, deviceMask);
	}

	void vkCmdDispatchBase(VkCommandBuffer commandBuffer,
	                       uint32_t baseGroupX,
	                       uint32_t baseGroupY,
	                       uint32_t baseGroupZ,
	                       uint32_t groupCountX,
	                       uint32_t groupCountY,
	                       uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
	}

	VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance,
	                                         uint32_t *pPhysicalDeviceGroupCount,
	                                         VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
	}

	void vkGetImageMemoryRequirements2(VkDevice device,
	                                   const VkImageMemoryRequirementsInfo2 *pInfo,
	                                   VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
	}

	void vkGetBufferMemoryRequirements2(VkDevice device,
	                                    const VkBufferMemoryRequirementsInfo2 *pInfo,
	                                    VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
	}

	void vkGetImageSparseMemoryRequirements2(VkDevice device,
	                                         const VkImageSparseMemoryRequirementsInfo2 *pInfo,
	                                         uint32_t *pSparseMemoryRequirementCount,
	                                         VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
	}

	void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
	}

	void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
	}

	void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
	                                          VkFormat format,
	                                          VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
	}

	VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,
	                                                   const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
	                                                   VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
	}

	void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
	                                               uint32_t *pQueueFamilyPropertyCount,
	                                               VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
	}

	void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
	                                          VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
	}

	void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,
	                                                     const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
	                                                     uint32_t *pPropertyCount,
	                                                     VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
	}

	void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkTrimCommandPool(device, commandPool, flags);
	}

	void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceQueue2(device, pQueueInfo, pQueue);
	}

	VkResult vkCreateSamplerYcbcrConversion(VkDevice device,
	                                        const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
	                                        const VkAllocationCallbacks *pAllocator,
	                                        VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
	}

	void vkDestroySamplerYcbcrConversion(VkDevice device,
	                                     VkSamplerYcbcrConversion ycbcrConversion,
	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
	}

	VkResult vkCreateDescriptorUpdateTemplate(VkDevice device,
	                                          const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
	                                          const VkAllocationCallbacks *pAllocator,
	                                          VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
	}

	void vkDestroyDescriptorUpdateTemplate(VkDevice device,
	                                       VkDescriptorUpdateTemplate descriptorUpdateTemplate,
	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
	}

	void vkUpdateDescriptorSetWithTemplate(VkDevice device,
	                                       VkDescriptorSet descriptorSet,
	                                       VkDescriptorUpdateTemplate descriptorUpdateTemplate,
	                                       const void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
	}

	void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,
	                                                 const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
	                                                 VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
	}

	void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,
	                                                const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
	                                                VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
	}

	void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,
	                                                    const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
	                                                    VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
	}

	void vkGetDescriptorSetLayoutSupport(VkDevice device,
	                                     const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
	                                     VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
	}

	//=== VK_VERSION_1_2 ===

	void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer,
	                            VkBuffer buffer,
	                            VkDeviceSize offset,
	                            VkBuffer countBuffer,
	                            VkDeviceSize countBufferOffset,
	                            uint32_t maxDrawCount,
	                            uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,
	                                   VkBuffer buffer,
	                                   VkDeviceSize offset,
	                                   VkBuffer countBuffer,
	                                   VkDeviceSize countBufferOffset,
	                                   uint32_t maxDrawCount,
	                                   uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	VkResult vkCreateRenderPass2(VkDevice device,
	                             const VkRenderPassCreateInfo2 *pCreateInfo,
	                             const VkAllocationCallbacks *pAllocator,
	                             VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
	}

	void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
	                           const VkRenderPassBeginInfo *pRenderPassBegin,
	                           const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
	}

	void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
	                       const VkSubpassBeginInfo *pSubpassBeginInfo,
	                       const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
	}

	void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
	}

	void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetQueryPool(device, queryPool, firstQuery, queryCount);
	}

	VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSemaphoreCounterValue(device, semaphore, pValue);
	}

	VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkWaitSemaphores(device, pWaitInfo, timeout);
	}

	VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSignalSemaphore(device, pSignalInfo);
	}

	VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferDeviceAddress(device, pInfo);
	}

	uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferOpaqueCaptureAddress(device, pInfo);
	}

	uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
	}

	//=== VK_VERSION_1_3 ===

	VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,
	                                           uint32_t *pToolCount,
	                                           VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
	}

	VkResult vkCreatePrivateDataSlot(VkDevice device,
	                                 const VkPrivateDataSlotCreateInfo *pCreateInfo,
	                                 const VkAllocationCallbacks *pAllocator,
	                                 VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
	}

	void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
	}

	VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
	}

	void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
	}

	void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetEvent2(commandBuffer, event, pDependencyInfo);
	}

	void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResetEvent2(commandBuffer, event, stageMask);
	}

	void vkCmdWaitEvents2(VkCommandBuffer commandBuffer,
	                      uint32_t eventCount,
	                      const VkEvent *pEvents,
	                      const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
	}

	void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo);
	}

	void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
	}

	VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueSubmit2(queue, submitCount, pSubmits, fence);
	}

	void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
	}

	void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImage2(commandBuffer, pCopyImageInfo);
	}

	void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
	}

	void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
	}

	void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBlitImage2(commandBuffer, pBlitImageInfo);
	}

	void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResolveImage2(commandBuffer, pResolveImageInfo);
	}

	void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginRendering(commandBuffer, pRenderingInfo);
	}

	void vkCmdEndRendering(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndRendering(commandBuffer);
	}

	void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetCullMode(commandBuffer, cullMode);
	}

	void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetFrontFace(commandBuffer, frontFace);
	}

	void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
	}

	void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
	}

	void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
	}

	void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer,
	                             uint32_t firstBinding,
	                             uint32_t bindingCount,
	                             const VkBuffer *pBuffers,
	                             const VkDeviceSize *pOffsets,
	                             const VkDeviceSize *pSizes,
	                             const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
	}

	void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable);
	}

	void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
	}

	void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp);
	}

	void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
	}

	void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
	}

	void vkCmdSetStencilOp(VkCommandBuffer commandBuffer,
	                       VkStencilFaceFlags faceMask,
	                       VkStencilOp failOp,
	                       VkStencilOp passOp,
	                       VkStencilOp depthFailOp,
	                       VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
	}

	void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
	}

	void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
	}

	void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
	}

	void vkGetDeviceBufferMemoryRequirements(VkDevice device,
	                                         const VkDeviceBufferMemoryRequirements *pInfo,
	                                         VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
	}

	void vkGetDeviceImageMemoryRequirements(VkDevice device,
	                                        const VkDeviceImageMemoryRequirements *pInfo,
	                                        VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
	}

	void vkGetDeviceImageSparseMemoryRequirements(VkDevice device,
	                                              const VkDeviceImageMemoryRequirements *pInfo,
	                                              uint32_t *pSparseMemoryRequirementCount,
	                                              VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
	}

	//=== VK_KHR_surface ===

	void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySurfaceKHR(instance, surface, pAllocator);
	}

	VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
	                                              uint32_t queueFamilyIndex,
	                                              VkSurfaceKHR surface,
	                                              VkBool32 *pSupported) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
	}

	VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
	                                                   VkSurfaceKHR surface,
	                                                   VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
	}

	VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
	                                              VkSurfaceKHR surface,
	                                              uint32_t *pSurfaceFormatCount,
	                                              VkSurfaceFormatKHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
	}

	VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
	                                                   VkSurfaceKHR surface,
	                                                   uint32_t *pPresentModeCount,
	                                                   VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
	}

	//=== VK_KHR_swapchain ===

	VkResult vkCreateSwapchainKHR(VkDevice device,
	                              const VkSwapchainCreateInfoKHR *pCreateInfo,
	                              const VkAllocationCallbacks *pAllocator,
	                              VkSwapchainKHR *pSwapchain) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
	}

	void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySwapchainKHR(device, swapchain, pAllocator);
	}

	VkResult vkGetSwapchainImagesKHR(VkDevice device,
	                                 VkSwapchainKHR swapchain,
	                                 uint32_t *pSwapchainImageCount,
	                                 VkImage *pSwapchainImages) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
	}

	VkResult vkAcquireNextImageKHR(
	    VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
	}

	VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueuePresentKHR(queue, pPresentInfo);
	}

	VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,
	                                                VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
	}

	VkResult
	vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
	}

	VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
	                                                 VkSurfaceKHR surface,
	                                                 uint32_t *pRectCount,
	                                                 VkRect2D *pRects) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
	}

	VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
	}

	//=== VK_KHR_display ===

	VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                 uint32_t *pPropertyCount,
	                                                 VkDisplayPropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
	}

	VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                      uint32_t *pPropertyCount,
	                                                      VkDisplayPlanePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
	}

	VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
	                                               uint32_t planeIndex,
	                                               uint32_t *pDisplayCount,
	                                               VkDisplayKHR *pDisplays) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
	}

	VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
	                                       VkDisplayKHR display,
	                                       uint32_t *pPropertyCount,
	                                       VkDisplayModePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
	}

	VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
	                                VkDisplayKHR display,
	                                const VkDisplayModeCreateInfoKHR *pCreateInfo,
	                                const VkAllocationCallbacks *pAllocator,
	                                VkDisplayModeKHR *pMode) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
	}

	VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
	                                          VkDisplayModeKHR mode,
	                                          uint32_t planeIndex,
	                                          VkDisplayPlaneCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
	}

	VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
	                                        const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
	                                        const VkAllocationCallbacks *pAllocator,
	                                        VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}

	//=== VK_KHR_display_swapchain ===

	VkResult vkCreateSharedSwapchainsKHR(VkDevice device,
	                                     uint32_t swapchainCount,
	                                     const VkSwapchainCreateInfoKHR *pCreateInfos,
	                                     const VkAllocationCallbacks *pAllocator,
	                                     VkSwapchainKHR *pSwapchains) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
	}

#	if defined(VK_USE_PLATFORM_XLIB_KHR)
	//=== VK_KHR_xlib_surface ===

	VkResult vkCreateXlibSurfaceKHR(VkInstance instance,
	                                const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
	                                const VkAllocationCallbacks *pAllocator,
	                                VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
	                                                       uint32_t queueFamilyIndex,
	                                                       Display *dpy,
	                                                       VisualID visualID) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
	}
#	endif /*VK_USE_PLATFORM_XLIB_KHR*/

#	if defined(VK_USE_PLATFORM_XCB_KHR)
	//=== VK_KHR_xcb_surface ===

	VkResult vkCreateXcbSurfaceKHR(VkInstance instance,
	                               const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
	                               const VkAllocationCallbacks *pAllocator,
	                               VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
	                                                      uint32_t queueFamilyIndex,
	                                                      xcb_connection_t *connection,
	                                                      xcb_visualid_t visual_id) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
	}
#	endif /*VK_USE_PLATFORM_XCB_KHR*/

#	if defined(VK_USE_PLATFORM_WAYLAND_KHR)
	//=== VK_KHR_wayland_surface ===

	VkResult vkCreateWaylandSurfaceKHR(VkInstance instance,
	                                   const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
	                                   const VkAllocationCallbacks *pAllocator,
	                                   VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
	                                                          uint32_t queueFamilyIndex,
	                                                          struct wl_display *display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
	}
#	endif /*VK_USE_PLATFORM_WAYLAND_KHR*/

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
	//=== VK_KHR_android_surface ===

	VkResult vkCreateAndroidSurfaceKHR(VkInstance instance,
	                                   const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
	                                   const VkAllocationCallbacks *pAllocator,
	                                   VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_win32_surface ===

	VkResult vkCreateWin32SurfaceKHR(VkInstance instance,
	                                 const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
	                                 const VkAllocationCallbacks *pAllocator,
	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_EXT_debug_report ===

	VkResult vkCreateDebugReportCallbackEXT(VkInstance instance,
	                                        const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
	                                        const VkAllocationCallbacks *pAllocator,
	                                        VkDebugReportCallbackEXT *pCallback) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
	}

	void vkDestroyDebugReportCallbackEXT(VkInstance instance,
	                                     VkDebugReportCallbackEXT callback,
	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
	}

	void vkDebugReportMessageEXT(VkInstance instance,
	                             VkDebugReportFlagsEXT flags,
	                             VkDebugReportObjectTypeEXT objectType,
	                             uint64_t object,
	                             size_t location,
	                             int32_t messageCode,
	                             const char *pLayerPrefix,
	                             const char *pMessage) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
	}

	//=== VK_EXT_debug_marker ===

	VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
	}

	VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
	}

	void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
	}

	void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDebugMarkerEndEXT(commandBuffer);
	}

	void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
	}

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_queue ===

	VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
	                                                 const VkVideoProfileKHR *pVideoProfile,
	                                                 VkVideoCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities);
	}

	VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                     const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo,
	                                                     uint32_t *pVideoFormatPropertyCount,
	                                                     VkVideoFormatPropertiesKHR *pVideoFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
	}

	VkResult vkCreateVideoSessionKHR(VkDevice device,
	                                 const VkVideoSessionCreateInfoKHR *pCreateInfo,
	                                 const VkAllocationCallbacks *pAllocator,
	                                 VkVideoSessionKHR *pVideoSession) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
	}

	void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyVideoSessionKHR(device, videoSession, pAllocator);
	}

	VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device,
	                                                VkVideoSessionKHR videoSession,
	                                                uint32_t *pVideoSessionMemoryRequirementsCount,
	                                                VkVideoGetMemoryPropertiesKHR *pVideoSessionMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
	}

	VkResult vkBindVideoSessionMemoryKHR(VkDevice device,
	                                     VkVideoSessionKHR videoSession,
	                                     uint32_t videoSessionBindMemoryCount,
	                                     const VkVideoBindMemoryKHR *pVideoSessionBindMemories) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories);
	}

	VkResult vkCreateVideoSessionParametersKHR(VkDevice device,
	                                           const VkVideoSessionParametersCreateInfoKHR *pCreateInfo,
	                                           const VkAllocationCallbacks *pAllocator,
	                                           VkVideoSessionParametersKHR *pVideoSessionParameters) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
	}

	VkResult vkUpdateVideoSessionParametersKHR(VkDevice device,
	                                           VkVideoSessionParametersKHR videoSessionParameters,
	                                           const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
	}

	void vkDestroyVideoSessionParametersKHR(VkDevice device,
	                                        VkVideoSessionParametersKHR videoSessionParameters,
	                                        const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
	}

	void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
	}

	void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
	}

	void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
	}
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_decode_queue ===

	void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pFrameInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDecodeVideoKHR(commandBuffer, pFrameInfo);
	}
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

	//=== VK_EXT_transform_feedback ===

	void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
	                                          uint32_t firstBinding,
	                                          uint32_t bindingCount,
	                                          const VkBuffer *pBuffers,
	                                          const VkDeviceSize *pOffsets,
	                                          const VkDeviceSize *pSizes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
	}

	void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
	                                    uint32_t firstCounterBuffer,
	                                    uint32_t counterBufferCount,
	                                    const VkBuffer *pCounterBuffers,
	                                    const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
	}

	void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
	                                  uint32_t firstCounterBuffer,
	                                  uint32_t counterBufferCount,
	                                  const VkBuffer *pCounterBuffers,
	                                  const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
	}

	void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
	}

	void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
	}

	void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
	                                   uint32_t instanceCount,
	                                   uint32_t firstInstance,
	                                   VkBuffer counterBuffer,
	                                   VkDeviceSize counterBufferOffset,
	                                   uint32_t counterOffset,
	                                   uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
	}

	//=== VK_NVX_binary_import ===

	VkResult vkCreateCuModuleNVX(VkDevice device,
	                             const VkCuModuleCreateInfoNVX *pCreateInfo,
	                             const VkAllocationCallbacks *pAllocator,
	                             VkCuModuleNVX *pModule) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
	}

	VkResult vkCreateCuFunctionNVX(VkDevice device,
	                               const VkCuFunctionCreateInfoNVX *pCreateInfo,
	                               const VkAllocationCallbacks *pAllocator,
	                               VkCuFunctionNVX *pFunction) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
	}

	void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyCuModuleNVX(device, module, pAllocator);
	}

	void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyCuFunctionNVX(device, function, pAllocator);
	}

	void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
	}

	//=== VK_NVX_image_view_handle ===

	uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageViewHandleNVX(device, pInfo);
	}

	VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageViewAddressNVX(device, imageView, pProperties);
	}

	//=== VK_AMD_draw_indirect_count ===

	void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,
	                               VkBuffer buffer,
	                               VkDeviceSize offset,
	                               VkBuffer countBuffer,
	                               VkDeviceSize countBufferOffset,
	                               uint32_t maxDrawCount,
	                               uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,
	                                      VkBuffer buffer,
	                                      VkDeviceSize offset,
	                                      VkBuffer countBuffer,
	                                      VkDeviceSize countBufferOffset,
	                                      uint32_t maxDrawCount,
	                                      uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	//=== VK_AMD_shader_info ===

	VkResult vkGetShaderInfoAMD(VkDevice device,
	                            VkPipeline pipeline,
	                            VkShaderStageFlagBits shaderStage,
	                            VkShaderInfoTypeAMD infoType,
	                            size_t *pInfoSize,
	                            void *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
	}

	//=== VK_KHR_dynamic_rendering ===

	void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo);
	}

	void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndRenderingKHR(commandBuffer);
	}

#	if defined(VK_USE_PLATFORM_GGP)
	//=== VK_GGP_stream_descriptor_surface ===

	VkResult vkCreateStreamDescriptorSurfaceGGP(VkInstance instance,
	                                            const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo,
	                                            const VkAllocationCallbacks *pAllocator,
	                                            VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_GGP*/

	//=== VK_NV_external_memory_capabilities ===

	VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,
	                                                            VkFormat format,
	                                                            VkImageType type,
	                                                            VkImageTiling tiling,
	                                                            VkImageUsageFlags usage,
	                                                            VkImageCreateFlags flags,
	                                                            VkExternalMemoryHandleTypeFlagsNV externalHandleType,
	                                                            VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
		    physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_NV_external_memory_win32 ===

	VkResult vkGetMemoryWin32HandleNV(VkDevice device,
	                                  VkDeviceMemory memory,
	                                  VkExternalMemoryHandleTypeFlagsNV handleType,
	                                  HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_get_physical_device_properties2 ===

	void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
	}

	void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
	}

	void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
	                                             VkFormat format,
	                                             VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
	}

	VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
	                                                      const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
	                                                      VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
	}

	void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
	                                                  uint32_t *pQueueFamilyPropertyCount,
	                                                  VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
	}

	void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
	                                             VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
	}

	void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
	                                                        const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
	                                                        uint32_t *pPropertyCount,
	                                                        VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
	}

	//=== VK_KHR_device_group ===

	void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device,
	                                           uint32_t heapIndex,
	                                           uint32_t localDeviceIndex,
	                                           uint32_t remoteDeviceIndex,
	                                           VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
	}

	void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
	}

	void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer,
	                          uint32_t baseGroupX,
	                          uint32_t baseGroupY,
	                          uint32_t baseGroupZ,
	                          uint32_t groupCountX,
	                          uint32_t groupCountY,
	                          uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
	}

#	if defined(VK_USE_PLATFORM_VI_NN)
	//=== VK_NN_vi_surface ===

	VkResult vkCreateViSurfaceNN(VkInstance instance,
	                             const VkViSurfaceCreateInfoNN *pCreateInfo,
	                             const VkAllocationCallbacks *pAllocator,
	                             VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_VI_NN*/

	//=== VK_KHR_maintenance1 ===

	void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkTrimCommandPoolKHR(device, commandPool, flags);
	}

	//=== VK_KHR_device_group_creation ===

	VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
	                                            uint32_t *pPhysicalDeviceGroupCount,
	                                            VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
	}

	//=== VK_KHR_external_memory_capabilities ===

	void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                    const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
	                                                    VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_memory_win32 ===

	VkResult vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
	}

	VkResult vkGetMemoryWin32HandlePropertiesKHR(VkDevice device,
	                                             VkExternalMemoryHandleTypeFlagBits handleType,
	                                             HANDLE handle,
	                                             VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_memory_fd ===

	VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
	}

	VkResult vkGetMemoryFdPropertiesKHR(VkDevice device,
	                                    VkExternalMemoryHandleTypeFlagBits handleType,
	                                    int fd,
	                                    VkMemoryFdPropertiesKHR *pMemoryFdProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
	}

	//=== VK_KHR_external_semaphore_capabilities ===

	void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                       const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
	                                                       VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_semaphore_win32 ===

	VkResult vkImportSemaphoreWin32HandleKHR(VkDevice device,
	                                         const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
	}

	VkResult
	vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_semaphore_fd ===

	VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
	}

	VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
	}

	//=== VK_KHR_push_descriptor ===

	void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
	                               VkPipelineBindPoint pipelineBindPoint,
	                               VkPipelineLayout layout,
	                               uint32_t set,
	                               uint32_t descriptorWriteCount,
	                               const VkWriteDescriptorSet *pDescriptorWrites) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
	}

	void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
	                                           VkDescriptorUpdateTemplate descriptorUpdateTemplate,
	                                           VkPipelineLayout layout,
	                                           uint32_t set,
	                                           const void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
	}

	//=== VK_EXT_conditional_rendering ===

	void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,
	                                       const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
	}

	void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndConditionalRenderingEXT(commandBuffer);
	}

	//=== VK_KHR_descriptor_update_template ===

	VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
	                                             const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
	                                             const VkAllocationCallbacks *pAllocator,
	                                             VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
	}

	void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device,
	                                          VkDescriptorUpdateTemplate descriptorUpdateTemplate,
	                                          const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
	}

	void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device,
	                                          VkDescriptorSet descriptorSet,
	                                          VkDescriptorUpdateTemplate descriptorUpdateTemplate,
	                                          const void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
	}

	//=== VK_NV_clip_space_w_scaling ===

	void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,
	                                uint32_t firstViewport,
	                                uint32_t viewportCount,
	                                const VkViewportWScalingNV *pViewportWScalings) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
	}

	//=== VK_EXT_direct_mode_display ===

	VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkReleaseDisplayEXT(physicalDevice, display);
	}

#	if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
	//=== VK_EXT_acquire_xlib_display ===

	VkResult vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
	}

	VkResult vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
	}
#	endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/

	//=== VK_EXT_display_surface_counter ===

	VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
	                                                    VkSurfaceKHR surface,
	                                                    VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
	}

	//=== VK_EXT_display_control ===

	VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
	}

	VkResult vkRegisterDeviceEventEXT(VkDevice device,
	                                  const VkDeviceEventInfoEXT *pDeviceEventInfo,
	                                  const VkAllocationCallbacks *pAllocator,
	                                  VkFence *pFence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
	}

	VkResult vkRegisterDisplayEventEXT(VkDevice device,
	                                   VkDisplayKHR display,
	                                   const VkDisplayEventInfoEXT *pDisplayEventInfo,
	                                   const VkAllocationCallbacks *pAllocator,
	                                   VkFence *pFence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
	}

	VkResult vkGetSwapchainCounterEXT(VkDevice device,
	                                  VkSwapchainKHR swapchain,
	                                  VkSurfaceCounterFlagBitsEXT counter,
	                                  uint64_t *pCounterValue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
	}

	//=== VK_GOOGLE_display_timing ===

	VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device,
	                                         VkSwapchainKHR swapchain,
	                                         VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
	}

	VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device,
	                                           VkSwapchainKHR swapchain,
	                                           uint32_t *pPresentationTimingCount,
	                                           VkPastPresentationTimingGOOGLE *pPresentationTimings) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
	}

	//=== VK_EXT_discard_rectangles ===

	void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
	                                 uint32_t firstDiscardRectangle,
	                                 uint32_t discardRectangleCount,
	                                 const VkRect2D *pDiscardRectangles) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
	}

	//=== VK_EXT_hdr_metadata ===

	void vkSetHdrMetadataEXT(VkDevice device,
	                         uint32_t swapchainCount,
	                         const VkSwapchainKHR *pSwapchains,
	                         const VkHdrMetadataEXT *pMetadata) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
	}

	//=== VK_KHR_create_renderpass2 ===

	VkResult vkCreateRenderPass2KHR(VkDevice device,
	                                const VkRenderPassCreateInfo2 *pCreateInfo,
	                                const VkAllocationCallbacks *pAllocator,
	                                VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
	}

	void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
	                              const VkRenderPassBeginInfo *pRenderPassBegin,
	                              const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
	}

	void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
	                          const VkSubpassBeginInfo *pSubpassBeginInfo,
	                          const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
	}

	void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
	}

	//=== VK_KHR_shared_presentable_image ===

	VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSwapchainStatusKHR(device, swapchain);
	}

	//=== VK_KHR_external_fence_capabilities ===

	void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice,
	                                                   const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
	                                                   VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_fence_win32 ===

	VkResult vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
	}

	VkResult vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_fence_fd ===

	VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkImportFenceFdKHR(device, pImportFenceFdInfo);
	}

	VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetFenceFdKHR(device, pGetFdInfo, pFd);
	}

	//=== VK_KHR_performance_query ===

	VkResult
	vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,
	                                                                uint32_t queueFamilyIndex,
	                                                                uint32_t *pCounterCount,
	                                                                VkPerformanceCounterKHR *pCounters,
	                                                                VkPerformanceCounterDescriptionKHR *pCounterDescriptions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
		    physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
	}

	void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,
	                                                             const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo,
	                                                             uint32_t *pNumPasses) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
	}

	VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireProfilingLockKHR(device, pInfo);
	}

	void vkReleaseProfilingLockKHR(VkDevice device) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkReleaseProfilingLockKHR(device);
	}

	//=== VK_KHR_get_surface_capabilities2 ===

	VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
	                                                    const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
	                                                    VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
	}

	VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
	                                               const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
	                                               uint32_t *pSurfaceFormatCount,
	                                               VkSurfaceFormat2KHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
	}

	//=== VK_KHR_get_display_properties2 ===

	VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
	                                                  uint32_t *pPropertyCount,
	                                                  VkDisplayProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
	}

	VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
	                                                       uint32_t *pPropertyCount,
	                                                       VkDisplayPlaneProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
	}

	VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
	                                        VkDisplayKHR display,
	                                        uint32_t *pPropertyCount,
	                                        VkDisplayModeProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
	}

	VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
	                                           const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
	                                           VkDisplayPlaneCapabilities2KHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
	}

#	if defined(VK_USE_PLATFORM_IOS_MVK)
	//=== VK_MVK_ios_surface ===

	VkResult vkCreateIOSSurfaceMVK(VkInstance instance,
	                               const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
	                               const VkAllocationCallbacks *pAllocator,
	                               VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_IOS_MVK*/

#	if defined(VK_USE_PLATFORM_MACOS_MVK)
	//=== VK_MVK_macos_surface ===

	VkResult vkCreateMacOSSurfaceMVK(VkInstance instance,
	                                 const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
	                                 const VkAllocationCallbacks *pAllocator,
	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_MACOS_MVK*/

	//=== VK_EXT_debug_utils ===

	VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
	}

	VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
	}

	void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
	}

	void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueEndDebugUtilsLabelEXT(queue);
	}

	void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
	}

	void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
	}

	void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEndDebugUtilsLabelEXT(commandBuffer);
	}

	void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
	}

	VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance,
	                                        const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
	                                        const VkAllocationCallbacks *pAllocator,
	                                        VkDebugUtilsMessengerEXT *pMessenger) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
	}

	void vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
	                                     VkDebugUtilsMessengerEXT messenger,
	                                     const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
	}

	void vkSubmitDebugUtilsMessageEXT(VkInstance instance,
	                                  VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
	                                  VkDebugUtilsMessageTypeFlagsEXT messageTypes,
	                                  const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
	}

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
	//=== VK_ANDROID_external_memory_android_hardware_buffer ===

	VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device,
	                                                     const struct AHardwareBuffer *buffer,
	                                                     VkAndroidHardwareBufferPropertiesANDROID *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
	}

	VkResult vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device,
	                                                 const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
	                                                 struct AHardwareBuffer **pBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
	}
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

	//=== VK_EXT_sample_locations ===

	void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
	}

	void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,
	                                                 VkSampleCountFlagBits samples,
	                                                 VkMultisamplePropertiesEXT *pMultisampleProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
	}

	//=== VK_KHR_get_memory_requirements2 ===

	void vkGetImageMemoryRequirements2KHR(VkDevice device,
	                                      const VkImageMemoryRequirementsInfo2 *pInfo,
	                                      VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
	}

	void vkGetBufferMemoryRequirements2KHR(VkDevice device,
	                                       const VkBufferMemoryRequirementsInfo2 *pInfo,
	                                       VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
	}

	void vkGetImageSparseMemoryRequirements2KHR(VkDevice device,
	                                            const VkImageSparseMemoryRequirementsInfo2 *pInfo,
	                                            uint32_t *pSparseMemoryRequirementCount,
	                                            VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
	}

	//=== VK_KHR_acceleration_structure ===

	VkResult vkCreateAccelerationStructureKHR(VkDevice device,
	                                          const VkAccelerationStructureCreateInfoKHR *pCreateInfo,
	                                          const VkAllocationCallbacks *pAllocator,
	                                          VkAccelerationStructureKHR *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
	}

	void vkDestroyAccelerationStructureKHR(VkDevice device,
	                                       VkAccelerationStructureKHR accelerationStructure,
	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
	}

	void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer,
	                                         uint32_t infoCount,
	                                         const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
	                                         const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
	}

	void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer,
	                                                 uint32_t infoCount,
	                                                 const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
	                                                 const VkDeviceAddress *pIndirectDeviceAddresses,
	                                                 const uint32_t *pIndirectStrides,
	                                                 const uint32_t *const *ppMaxPrimitiveCounts) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBuildAccelerationStructuresIndirectKHR(
		    commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
	}

	VkResult vkBuildAccelerationStructuresKHR(VkDevice device,
	                                          VkDeferredOperationKHR deferredOperation,
	                                          uint32_t infoCount,
	                                          const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
	                                          const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
	}

	VkResult vkCopyAccelerationStructureKHR(VkDevice device,
	                                        VkDeferredOperationKHR deferredOperation,
	                                        const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
	}

	VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device,
	                                                VkDeferredOperationKHR deferredOperation,
	                                                const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
	}

	VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device,
	                                                VkDeferredOperationKHR deferredOperation,
	                                                const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
	}

	VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device,
	                                                    uint32_t accelerationStructureCount,
	                                                    const VkAccelerationStructureKHR *pAccelerationStructures,
	                                                    VkQueryType queryType,
	                                                    size_t dataSize,
	                                                    void *pData,
	                                                    size_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
	}

	void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
	}

	void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,
	                                               const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
	}

	void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,
	                                               const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
	}

	VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device,
	                                                           const VkAccelerationStructureDeviceAddressInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
	}

	void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer,
	                                                   uint32_t accelerationStructureCount,
	                                                   const VkAccelerationStructureKHR *pAccelerationStructures,
	                                                   VkQueryType queryType,
	                                                   VkQueryPool queryPool,
	                                                   uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
		    commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
	}

	void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device,
	                                                      const VkAccelerationStructureVersionInfoKHR *pVersionInfo,
	                                                      VkAccelerationStructureCompatibilityKHR *pCompatibility) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
	}

	void vkGetAccelerationStructureBuildSizesKHR(VkDevice device,
	                                             VkAccelerationStructureBuildTypeKHR buildType,
	                                             const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo,
	                                             const uint32_t *pMaxPrimitiveCounts,
	                                             VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
	}

	//=== VK_KHR_sampler_ycbcr_conversion ===

	VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device,
	                                           const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
	                                           const VkAllocationCallbacks *pAllocator,
	                                           VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
	}

	void vkDestroySamplerYcbcrConversionKHR(VkDevice device,
	                                        VkSamplerYcbcrConversion ycbcrConversion,
	                                        const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
	}

	//=== VK_KHR_bind_memory2 ===

	VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
	}

	VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
	}

	//=== VK_EXT_image_drm_format_modifier ===

	VkResult
	vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
	}

	//=== VK_EXT_validation_cache ===

	VkResult vkCreateValidationCacheEXT(VkDevice device,
	                                    const VkValidationCacheCreateInfoEXT *pCreateInfo,
	                                    const VkAllocationCallbacks *pAllocator,
	                                    VkValidationCacheEXT *pValidationCache) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
	}

	void
	vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
	}

	VkResult vkMergeValidationCachesEXT(VkDevice device,
	                                    VkValidationCacheEXT dstCache,
	                                    uint32_t srcCacheCount,
	                                    const VkValidationCacheEXT *pSrcCaches) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
	}

	VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
	}

	//=== VK_NV_shading_rate_image ===

	void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
	}

	void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,
	                                          uint32_t firstViewport,
	                                          uint32_t viewportCount,
	                                          const VkShadingRatePaletteNV *pShadingRatePalettes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
	}

	void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
	                                 VkCoarseSampleOrderTypeNV sampleOrderType,
	                                 uint32_t customSampleOrderCount,
	                                 const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
	}

	//=== VK_NV_ray_tracing ===

	VkResult vkCreateAccelerationStructureNV(VkDevice device,
	                                         const VkAccelerationStructureCreateInfoNV *pCreateInfo,
	                                         const VkAllocationCallbacks *pAllocator,
	                                         VkAccelerationStructureNV *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
	}

	void vkDestroyAccelerationStructureNV(VkDevice device,
	                                      VkAccelerationStructureNV accelerationStructure,
	                                      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
	}

	void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device,
	                                                    const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo,
	                                                    VkMemoryRequirements2KHR *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
	}

	VkResult vkBindAccelerationStructureMemoryNV(VkDevice device,
	                                             uint32_t bindInfoCount,
	                                             const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
	}

	void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
	                                       const VkAccelerationStructureInfoNV *pInfo,
	                                       VkBuffer instanceData,
	                                       VkDeviceSize instanceOffset,
	                                       VkBool32 update,
	                                       VkAccelerationStructureNV dst,
	                                       VkAccelerationStructureNV src,
	                                       VkBuffer scratch,
	                                       VkDeviceSize scratchOffset) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
	}

	void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
	                                      VkAccelerationStructureNV dst,
	                                      VkAccelerationStructureNV src,
	                                      VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
	}

	void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer,
	                      VkBuffer raygenShaderBindingTableBuffer,
	                      VkDeviceSize raygenShaderBindingOffset,
	                      VkBuffer missShaderBindingTableBuffer,
	                      VkDeviceSize missShaderBindingOffset,
	                      VkDeviceSize missShaderBindingStride,
	                      VkBuffer hitShaderBindingTableBuffer,
	                      VkDeviceSize hitShaderBindingOffset,
	                      VkDeviceSize hitShaderBindingStride,
	                      VkBuffer callableShaderBindingTableBuffer,
	                      VkDeviceSize callableShaderBindingOffset,
	                      VkDeviceSize callableShaderBindingStride,
	                      uint32_t width,
	                      uint32_t height,
	                      uint32_t depth) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdTraceRaysNV(commandBuffer,
		                          raygenShaderBindingTableBuffer,
		                          raygenShaderBindingOffset,
		                          missShaderBindingTableBuffer,
		                          missShaderBindingOffset,
		                          missShaderBindingStride,
		                          hitShaderBindingTableBuffer,
		                          hitShaderBindingOffset,
		                          hitShaderBindingStride,
		                          callableShaderBindingTableBuffer,
		                          callableShaderBindingOffset,
		                          callableShaderBindingStride,
		                          width,
		                          height,
		                          depth);
	}

	VkResult vkCreateRayTracingPipelinesNV(VkDevice device,
	                                       VkPipelineCache pipelineCache,
	                                       uint32_t createInfoCount,
	                                       const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
	                                       const VkAllocationCallbacks *pAllocator,
	                                       VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
	}

	VkResult vkGetRayTracingShaderGroupHandlesNV(
	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
	}

	VkResult vkGetAccelerationStructureHandleNV(VkDevice device,
	                                            VkAccelerationStructureNV accelerationStructure,
	                                            size_t dataSize,
	                                            void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
	}

	void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer,
	                                                  uint32_t accelerationStructureCount,
	                                                  const VkAccelerationStructureNV *pAccelerationStructures,
	                                                  VkQueryType queryType,
	                                                  VkQueryPool queryPool,
	                                                  uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteAccelerationStructuresPropertiesNV(
		    commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
	}

	VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCompileDeferredNV(device, pipeline, shader);
	}

	//=== VK_KHR_maintenance3 ===

	void vkGetDescriptorSetLayoutSupportKHR(VkDevice device,
	                                        const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
	                                        VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
	}

	//=== VK_KHR_draw_indirect_count ===

	void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer,
	                               VkBuffer buffer,
	                               VkDeviceSize offset,
	                               VkBuffer countBuffer,
	                               VkDeviceSize countBufferOffset,
	                               uint32_t maxDrawCount,
	                               uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer,
	                                      VkBuffer buffer,
	                                      VkDeviceSize offset,
	                                      VkBuffer countBuffer,
	                                      VkDeviceSize countBufferOffset,
	                                      uint32_t maxDrawCount,
	                                      uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	//=== VK_EXT_external_memory_host ===

	VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device,
	                                             VkExternalMemoryHandleTypeFlagBits handleType,
	                                             const void *pHostPointer,
	                                             VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
	}

	//=== VK_AMD_buffer_marker ===

	void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
	                               VkPipelineStageFlagBits pipelineStage,
	                               VkBuffer dstBuffer,
	                               VkDeviceSize dstOffset,
	                               uint32_t marker) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
	}

	//=== VK_EXT_calibrated_timestamps ===

	VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
	                                                        uint32_t *pTimeDomainCount,
	                                                        VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
	}

	VkResult vkGetCalibratedTimestampsEXT(VkDevice device,
	                                      uint32_t timestampCount,
	                                      const VkCalibratedTimestampInfoEXT *pTimestampInfos,
	                                      uint64_t *pTimestamps,
	                                      uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
	}

	//=== VK_NV_mesh_shader ===

	void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
	}

	void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
	}

	void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer,
	                                       VkBuffer buffer,
	                                       VkDeviceSize offset,
	                                       VkBuffer countBuffer,
	                                       VkDeviceSize countBufferOffset,
	                                       uint32_t maxDrawCount,
	                                       uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
	}

	//=== VK_NV_scissor_exclusive ===

	void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
	                                uint32_t firstExclusiveScissor,
	                                uint32_t exclusiveScissorCount,
	                                const VkRect2D *pExclusiveScissors) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
	}

	//=== VK_NV_device_diagnostic_checkpoints ===

	void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
	}

	void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
	}

	//=== VK_KHR_timeline_semaphore ===

	VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
	}

	VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
	}

	VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSignalSemaphoreKHR(device, pSignalInfo);
	}

	//=== VK_INTEL_performance_query ===

	VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkInitializePerformanceApiINTEL(device, pInitializeInfo);
	}

	void vkUninitializePerformanceApiINTEL(VkDevice device) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkUninitializePerformanceApiINTEL(device);
	}

	VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
	}

	VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
	                                              const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
	}

	VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
	}

	VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device,
	                                                const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo,
	                                                VkPerformanceConfigurationINTEL *pConfiguration) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
	}

	VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkReleasePerformanceConfigurationINTEL(device, configuration);
	}

	VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
	}

	VkResult
	vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPerformanceParameterINTEL(device, parameter, pValue);
	}

	//=== VK_AMD_display_native_hdr ===

	void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable);
	}

#	if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_imagepipe_surface ===

	VkResult vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance,
	                                         const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
	                                         const VkAllocationCallbacks *pAllocator,
	                                         VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_METAL_EXT)
	//=== VK_EXT_metal_surface ===

	VkResult vkCreateMetalSurfaceEXT(VkInstance instance,
	                                 const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
	                                 const VkAllocationCallbacks *pAllocator,
	                                 VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
	}
#	endif /*VK_USE_PLATFORM_METAL_EXT*/

	//=== VK_KHR_fragment_shading_rate ===

	VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,
	                                                    uint32_t *pFragmentShadingRateCount,
	                                                    VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
	}

	void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,
	                                    const VkExtent2D *pFragmentSize,
	                                    const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
	}

	//=== VK_EXT_buffer_device_address ===

	VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferDeviceAddressEXT(device, pInfo);
	}

	//=== VK_EXT_tooling_info ===

	VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice,
	                                              uint32_t *pToolCount,
	                                              VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
	}

	//=== VK_KHR_present_wait ===

	VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkWaitForPresentKHR(device, swapchain, presentId, timeout);
	}

	//=== VK_NV_cooperative_matrix ===

	VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,
	                                                          uint32_t *pPropertyCount,
	                                                          VkCooperativeMatrixPropertiesNV *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
	}

	//=== VK_NV_coverage_reduction_mode ===

	VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
	    VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_EXT_full_screen_exclusive ===

	VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,
	                                                    const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
	                                                    uint32_t *pPresentModeCount,
	                                                    VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
	}

	VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireFullScreenExclusiveModeEXT(device, swapchain);
	}

	VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkReleaseFullScreenExclusiveModeEXT(device, swapchain);
	}

	VkResult vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
	                                                 const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
	                                                 VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_EXT_headless_surface ===

	VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance,
	                                    const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo,
	                                    const VkAllocationCallbacks *pAllocator,
	                                    VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
	}

	//=== VK_KHR_buffer_device_address ===

	VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferDeviceAddressKHR(device, pInfo);
	}

	uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
	}

	uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
	}

	//=== VK_EXT_line_rasterization ===

	void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
	}

	//=== VK_EXT_host_query_reset ===

	void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
	}

	//=== VK_EXT_extended_dynamic_state ===

	void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetCullModeEXT(commandBuffer, cullMode);
	}

	void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
	}

	void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
	}

	void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
	}

	void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
	}

	void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
	                                uint32_t firstBinding,
	                                uint32_t bindingCount,
	                                const VkBuffer *pBuffers,
	                                const VkDeviceSize *pOffsets,
	                                const VkDeviceSize *pSizes,
	                                const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
	}

	void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
	}

	void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
	}

	void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
	}

	void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
	}

	void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
	}

	void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
	                          VkStencilFaceFlags faceMask,
	                          VkStencilOp failOp,
	                          VkStencilOp passOp,
	                          VkStencilOp depthFailOp,
	                          VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
	}

	//=== VK_KHR_deferred_host_operations ===

	VkResult vkCreateDeferredOperationKHR(VkDevice device,
	                                      const VkAllocationCallbacks *pAllocator,
	                                      VkDeferredOperationKHR *pDeferredOperation) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
	}

	void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyDeferredOperationKHR(device, operation, pAllocator);
	}

	uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeferredOperationMaxConcurrencyKHR(device, operation);
	}

	VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeferredOperationResultKHR(device, operation);
	}

	VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDeferredOperationJoinKHR(device, operation);
	}

	//=== VK_KHR_pipeline_executable_properties ===

	VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device,
	                                              const VkPipelineInfoKHR *pPipelineInfo,
	                                              uint32_t *pExecutableCount,
	                                              VkPipelineExecutablePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
	}

	VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device,
	                                              const VkPipelineExecutableInfoKHR *pExecutableInfo,
	                                              uint32_t *pStatisticCount,
	                                              VkPipelineExecutableStatisticKHR *pStatistics) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
	}

	VkResult
	vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,
	                                                  const VkPipelineExecutableInfoKHR *pExecutableInfo,
	                                                  uint32_t *pInternalRepresentationCount,
	                                                  VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
	}

	//=== VK_NV_device_generated_commands ===

	void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device,
	                                                const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo,
	                                                VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
	}

	void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
	}

	void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer,
	                                     VkBool32 isPreprocessed,
	                                     const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
	}

	void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
	                                    VkPipelineBindPoint pipelineBindPoint,
	                                    VkPipeline pipeline,
	                                    uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
	}

	VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device,
	                                          const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo,
	                                          const VkAllocationCallbacks *pAllocator,
	                                          VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
	}

	void vkDestroyIndirectCommandsLayoutNV(VkDevice device,
	                                       VkIndirectCommandsLayoutNV indirectCommandsLayout,
	                                       const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
	}

	//=== VK_EXT_acquire_drm_display ===

	VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display);
	}

	VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display);
	}

	//=== VK_EXT_private_data ===

	VkResult vkCreatePrivateDataSlotEXT(VkDevice device,
	                                    const VkPrivateDataSlotCreateInfo *pCreateInfo,
	                                    const VkAllocationCallbacks *pAllocator,
	                                    VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
	}

	void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
	}

	VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
	}

	void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
	    VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
	}

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_encode_queue ===

	void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
	}
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

	//=== VK_KHR_synchronization2 ===

	void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
	}

	void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
	}

	void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer,
	                         uint32_t eventCount,
	                         const VkEvent *pEvents,
	                         const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
	}

	void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
	}

	void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
	}

	VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
	}

	void vkCmdWriteBufferMarker2AMD(
	    VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
	}

	void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
	}

	//=== VK_NV_fragment_shading_rate_enums ===

	void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
	                                       VkFragmentShadingRateNV shadingRate,
	                                       const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
	}

	//=== VK_KHR_copy_commands2 ===

	void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
	}

	void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
	}

	void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
	}

	void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
	}

	void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
	}

	void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
	}

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_NV_acquire_winrt_display ===

	VkResult vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkAcquireWinrtDisplayNV(physicalDevice, display);
	}

	VkResult vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
	}
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
	//=== VK_EXT_directfb_surface ===

	VkResult vkCreateDirectFBSurfaceEXT(VkInstance instance,
	                                    const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo,
	                                    const VkAllocationCallbacks *pAllocator,
	                                    VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32
	vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb);
	}
#	endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/

	//=== VK_KHR_ray_tracing_pipeline ===

	void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer,
	                       const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
	                       const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
	                       const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
	                       const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
	                       uint32_t width,
	                       uint32_t height,
	                       uint32_t depth) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdTraceRaysKHR(
		    commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
	}

	VkResult vkCreateRayTracingPipelinesKHR(VkDevice device,
	                                        VkDeferredOperationKHR deferredOperation,
	                                        VkPipelineCache pipelineCache,
	                                        uint32_t createInfoCount,
	                                        const VkRayTracingPipelineCreateInfoKHR *pCreateInfos,
	                                        const VkAllocationCallbacks *pAllocator,
	                                        VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
	}

	VkResult vkGetRayTracingShaderGroupHandlesKHR(
	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
	}

	VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
	    VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
	}

	void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
	                               const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
	                               const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
	                               const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
	                               const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
	                               VkDeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdTraceRaysIndirectKHR(
		    commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
	}

	VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device,
	                                                    VkPipeline pipeline,
	                                                    uint32_t group,
	                                                    VkShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
	}

	void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
	}

	//=== VK_EXT_vertex_input_dynamic_state ===

	void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer,
	                            uint32_t vertexBindingDescriptionCount,
	                            const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions,
	                            uint32_t vertexAttributeDescriptionCount,
	                            const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetVertexInputEXT(
		    commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
	}

#	if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_external_memory ===

	VkResult vkGetMemoryZirconHandleFUCHSIA(VkDevice device,
	                                        const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
	                                        zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
	}

	VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device,
	                                                  VkExternalMemoryHandleTypeFlagBits handleType,
	                                                  zx_handle_t zirconHandle,
	                                                  VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
	}
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_external_semaphore ===

	VkResult vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device,
	                                              const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
	}

	VkResult vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device,
	                                           const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
	                                           zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
	}
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_buffer_collection ===

	VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device,
	                                         const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo,
	                                         const VkAllocationCallbacks *pAllocator,
	                                         VkBufferCollectionFUCHSIA *pCollection) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
	}

	VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device,
	                                                      VkBufferCollectionFUCHSIA collection,
	                                                      const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
	}

	VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device,
	                                                       VkBufferCollectionFUCHSIA collection,
	                                                       const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
	}

	void vkDestroyBufferCollectionFUCHSIA(VkDevice device,
	                                      VkBufferCollectionFUCHSIA collection,
	                                      const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
	}

	VkResult vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device,
	                                                VkBufferCollectionFUCHSIA collection,
	                                                VkBufferCollectionPropertiesFUCHSIA *pProperties) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
	}
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

	//=== VK_HUAWEI_subpass_shading ===

	VkResult
	vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
	}

	void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSubpassShadingHUAWEI(commandBuffer);
	}

	//=== VK_HUAWEI_invocation_mask ===

	void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
	}

	//=== VK_NV_external_memory_rdma ===

	VkResult vkGetMemoryRemoteAddressNV(VkDevice device,
	                                    const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo,
	                                    VkRemoteAddressNV *pAddress) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
	}

	//=== VK_EXT_extended_dynamic_state2 ===

	void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
	}

	void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable);
	}

	void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable);
	}

	void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetLogicOpEXT(commandBuffer, logicOp);
	}

	void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable);
	}

#	if defined(VK_USE_PLATFORM_SCREEN_QNX)
	//=== VK_QNX_screen_surface ===

	VkResult vkCreateScreenSurfaceQNX(VkInstance instance,
	                                  const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
	                                  const VkAllocationCallbacks *pAllocator,
	                                  VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
	}

	VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
	                                                         uint32_t queueFamilyIndex,
	                                                         struct _screen_window *window) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window);
	}
#	endif /*VK_USE_PLATFORM_SCREEN_QNX*/

	//=== VK_EXT_color_write_enable ===

	void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
	}

	//=== VK_EXT_multi_draw ===

	void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer,
	                       uint32_t drawCount,
	                       const VkMultiDrawInfoEXT *pVertexInfo,
	                       uint32_t instanceCount,
	                       uint32_t firstInstance,
	                       uint32_t stride) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
	}

	void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer,
	                              uint32_t drawCount,
	                              const VkMultiDrawIndexedInfoEXT *pIndexInfo,
	                              uint32_t instanceCount,
	                              uint32_t firstInstance,
	                              uint32_t stride,
	                              const int32_t *pVertexOffset) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
	}

	//=== VK_EXT_pageable_device_local_memory ===

	void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkSetDeviceMemoryPriorityEXT(device, memory, priority);
	}

	//=== VK_KHR_maintenance4 ===

	void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device,
	                                            const VkDeviceBufferMemoryRequirements *pInfo,
	                                            VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
	}

	void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device,
	                                           const VkDeviceImageMemoryRequirements *pInfo,
	                                           VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
	}

	void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device,
	                                                 const VkDeviceImageMemoryRequirements *pInfo,
	                                                 uint32_t *pSparseMemoryRequirementCount,
	                                                 VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
	}

	//=== VK_VALVE_descriptor_set_host_mapping ===

	void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device,
	                                                  const VkDescriptorSetBindingReferenceVALVE *pBindingReference,
	                                                  VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
	}

	void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) const VULKAN_HPP_NOEXCEPT
	{
		return ::vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
	}
};
#endif

class DispatchLoaderDynamic;
#if !defined(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC)
#	if defined(VK_NO_PROTOTYPES)
#		define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
#	else
#		define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
#	endif
#endif

#if !defined(VULKAN_HPP_STORAGE_API)
#	if defined(VULKAN_HPP_STORAGE_SHARED)
#		if defined(_MSC_VER)
#			if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
#				define VULKAN_HPP_STORAGE_API __declspec(dllexport)
#			else
#				define VULKAN_HPP_STORAGE_API __declspec(dllimport)
#			endif
#		elif defined(__clang__) || defined(__GNUC__)
#			if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
#				define VULKAN_HPP_STORAGE_API __attribute__((visibility("default")))
#			else
#				define VULKAN_HPP_STORAGE_API
#			endif
#		else
#			define VULKAN_HPP_STORAGE_API
#			pragma warning Unknown import / export semantics
#		endif
#	else
#		define VULKAN_HPP_STORAGE_API
#	endif
#endif

#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER)
#	if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
#		define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
#		define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                     \
			namespace VULKAN_HPP_NAMESPACE {                                           \
			VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
			}
extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
#	else
static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic &getDispatchLoaderStatic()
{
	static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
	return dls;
}
#		define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
#		define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
#	endif
#endif

#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER_TYPE)
#	if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
#		define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
#	else
#		define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
#	endif
#endif

#if defined(VULKAN_HPP_NO_DEFAULT_DISPATCHER)
#	define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
#	define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
#	define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
#else
#	define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
#	define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
#	define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
#endif

struct AllocationCallbacks;

template<typename OwnerType, typename Dispatch>
class ObjectDestroy
{
public:
	ObjectDestroy() = default;

	ObjectDestroy(OwnerType owner,
	              Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
	              Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
	    : m_owner(owner),
	      m_allocationCallbacks(allocationCallbacks),
	      m_dispatch(&dispatch)
	{
	}

	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
	{
		return m_owner;
	}
	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
	{
		return m_allocationCallbacks;
	}

protected:
	template<typename T>
	void destroy(T t) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
		m_owner.destroy(t, m_allocationCallbacks, *m_dispatch);
	}

private:
	OwnerType m_owner = {};
	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
	Dispatch const *m_dispatch = nullptr;
};

class NoParent;

template<typename Dispatch>
class ObjectDestroy<NoParent, Dispatch>
{
public:
	ObjectDestroy() = default;

	ObjectDestroy(Optional<const AllocationCallbacks> allocationCallbacks,
	              Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
	    : m_allocationCallbacks(allocationCallbacks),
	      m_dispatch(&dispatch)
	{
	}

	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
	{
		return m_allocationCallbacks;
	}

protected:
	template<typename T>
	void destroy(T t) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_dispatch);
		t.destroy(m_allocationCallbacks, *m_dispatch);
	}

private:
	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
	Dispatch const *m_dispatch = nullptr;
};

template<typename OwnerType, typename Dispatch>
class ObjectFree
{
public:
	ObjectFree() = default;

	ObjectFree(OwnerType owner,
	           Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
	           Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
	    : m_owner(owner),
	      m_allocationCallbacks(allocationCallbacks),
	      m_dispatch(&dispatch)
	{
	}

	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
	{
		return m_owner;
	}

	Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
	{
		return m_allocationCallbacks;
	}

protected:
	template<typename T>
	void destroy(T t) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
		(m_owner.free)(t, m_allocationCallbacks, *m_dispatch);
	}

private:
	OwnerType m_owner = {};
	Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
	Dispatch const *m_dispatch = nullptr;
};

template<typename OwnerType, typename Dispatch>
class ObjectRelease
{
public:
	ObjectRelease() = default;

	ObjectRelease(OwnerType owner, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
	    : m_owner(owner),
	      m_dispatch(&dispatch)
	{
	}

	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
	{
		return m_owner;
	}

protected:
	template<typename T>
	void destroy(T t) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(m_owner && m_dispatch);
		m_owner.release(t, *m_dispatch);
	}

private:
	OwnerType m_owner = {};
	Dispatch const *m_dispatch = nullptr;
};

template<typename OwnerType, typename PoolType, typename Dispatch>
class PoolFree
{
public:
	PoolFree() = default;

	PoolFree(OwnerType owner, PoolType pool, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
	    : m_owner(owner),
	      m_pool(pool),
	      m_dispatch(&dispatch)
	{
	}

	OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
	{
		return m_owner;
	}
	PoolType getPool() const VULKAN_HPP_NOEXCEPT
	{
		return m_pool;
	}

protected:
	template<typename T>
	void destroy(T t) VULKAN_HPP_NOEXCEPT
	{
		(m_owner.free)(m_pool, t, *m_dispatch);
	}

private:
	OwnerType m_owner = OwnerType();
	PoolType m_pool = PoolType();
	Dispatch const *m_dispatch = nullptr;
};

//==================
//=== BASE TYPEs ===
//==================

using Bool32 = uint32_t;
using DeviceAddress = uint64_t;
using DeviceSize = uint64_t;
using RemoteAddressNV = void *;
using SampleMask = uint32_t;

}  // namespace VULKAN_HPP_NAMESPACE

#include <vulkan/vulkan_enums.hpp>

#ifndef VULKAN_HPP_NO_EXCEPTIONS
namespace std {
template<>
struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
{
};
}  // namespace std
#endif

namespace VULKAN_HPP_NAMESPACE {
#ifndef VULKAN_HPP_NO_EXCEPTIONS

class ErrorCategoryImpl : public std::error_category
{
public:
	virtual const char *name() const VULKAN_HPP_NOEXCEPT override
	{
		return VULKAN_HPP_NAMESPACE_STRING "::Result";
	}
	virtual std::string message(int ev) const override
	{
		return to_string(static_cast<Result>(ev));
	}
};

class Error
{
public:
	Error() VULKAN_HPP_NOEXCEPT = default;
	Error(const Error &) VULKAN_HPP_NOEXCEPT = default;
	virtual ~Error() VULKAN_HPP_NOEXCEPT = default;

	virtual const char *what() const VULKAN_HPP_NOEXCEPT = 0;
};

class LogicError
    : public Error,
      public std::logic_error
{
public:
	explicit LogicError(const std::string &what)
	    : Error()
	    , std::logic_error(what)
	{}
	explicit LogicError(char const *what)
	    : Error()
	    , std::logic_error(what)
	{}

	virtual const char *what() const VULKAN_HPP_NOEXCEPT
	{
		return std::logic_error::what();
	}
};

class SystemError
    : public Error,
      public std::system_error
{
public:
	SystemError(std::error_code ec)
	    : Error()
	    , std::system_error(ec)
	{}
	SystemError(std::error_code ec, std::string const &what)
	    : Error()
	    , std::system_error(ec, what)
	{}
	SystemError(std::error_code ec, char const *what)
	    : Error()
	    , std::system_error(ec, what)
	{}
	SystemError(int ev, std::error_category const &ecat)
	    : Error()
	    , std::system_error(ev, ecat)
	{}
	SystemError(int ev, std::error_category const &ecat, std::string const &what)
	    : Error()
	    , std::system_error(ev, ecat, what)
	{}
	SystemError(int ev, std::error_category const &ecat, char const *what)
	    : Error()
	    , std::system_error(ev, ecat, what)
	{}

	virtual const char *what() const VULKAN_HPP_NOEXCEPT
	{
		return std::system_error::what();
	}
};

VULKAN_HPP_INLINE const std::error_category &errorCategory() VULKAN_HPP_NOEXCEPT
{
	static ErrorCategoryImpl instance;
	return instance;
}

VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
{
	return std::error_code(static_cast<int>(e), errorCategory());
}

VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
{
	return std::error_condition(static_cast<int>(e), errorCategory());
}

class OutOfHostMemoryError : public SystemError
{
public:
	OutOfHostMemoryError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message)
	{}
	OutOfHostMemoryError(char const *message)
	    : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message)
	{}
};

class OutOfDeviceMemoryError : public SystemError
{
public:
	OutOfDeviceMemoryError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message)
	{}
	OutOfDeviceMemoryError(char const *message)
	    : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message)
	{}
};

class InitializationFailedError : public SystemError
{
public:
	InitializationFailedError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorInitializationFailed), message)
	{}
	InitializationFailedError(char const *message)
	    : SystemError(make_error_code(Result::eErrorInitializationFailed), message)
	{}
};

class DeviceLostError : public SystemError
{
public:
	DeviceLostError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorDeviceLost), message)
	{}
	DeviceLostError(char const *message)
	    : SystemError(make_error_code(Result::eErrorDeviceLost), message)
	{}
};

class MemoryMapFailedError : public SystemError
{
public:
	MemoryMapFailedError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message)
	{}
	MemoryMapFailedError(char const *message)
	    : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message)
	{}
};

class LayerNotPresentError : public SystemError
{
public:
	LayerNotPresentError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorLayerNotPresent), message)
	{}
	LayerNotPresentError(char const *message)
	    : SystemError(make_error_code(Result::eErrorLayerNotPresent), message)
	{}
};

class ExtensionNotPresentError : public SystemError
{
public:
	ExtensionNotPresentError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message)
	{}
	ExtensionNotPresentError(char const *message)
	    : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message)
	{}
};

class FeatureNotPresentError : public SystemError
{
public:
	FeatureNotPresentError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message)
	{}
	FeatureNotPresentError(char const *message)
	    : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message)
	{}
};

class IncompatibleDriverError : public SystemError
{
public:
	IncompatibleDriverError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message)
	{}
	IncompatibleDriverError(char const *message)
	    : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message)
	{}
};

class TooManyObjectsError : public SystemError
{
public:
	TooManyObjectsError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorTooManyObjects), message)
	{}
	TooManyObjectsError(char const *message)
	    : SystemError(make_error_code(Result::eErrorTooManyObjects), message)
	{}
};

class FormatNotSupportedError : public SystemError
{
public:
	FormatNotSupportedError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorFormatNotSupported), message)
	{}
	FormatNotSupportedError(char const *message)
	    : SystemError(make_error_code(Result::eErrorFormatNotSupported), message)
	{}
};

class FragmentedPoolError : public SystemError
{
public:
	FragmentedPoolError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorFragmentedPool), message)
	{}
	FragmentedPoolError(char const *message)
	    : SystemError(make_error_code(Result::eErrorFragmentedPool), message)
	{}
};

class UnknownError : public SystemError
{
public:
	UnknownError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorUnknown), message)
	{}
	UnknownError(char const *message)
	    : SystemError(make_error_code(Result::eErrorUnknown), message)
	{}
};

class OutOfPoolMemoryError : public SystemError
{
public:
	OutOfPoolMemoryError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorOutOfPoolMemory), message)
	{}
	OutOfPoolMemoryError(char const *message)
	    : SystemError(make_error_code(Result::eErrorOutOfPoolMemory), message)
	{}
};

class InvalidExternalHandleError : public SystemError
{
public:
	InvalidExternalHandleError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorInvalidExternalHandle), message)
	{}
	InvalidExternalHandleError(char const *message)
	    : SystemError(make_error_code(Result::eErrorInvalidExternalHandle), message)
	{}
};

class FragmentationError : public SystemError
{
public:
	FragmentationError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorFragmentation), message)
	{}
	FragmentationError(char const *message)
	    : SystemError(make_error_code(Result::eErrorFragmentation), message)
	{}
};

class InvalidOpaqueCaptureAddressError : public SystemError
{
public:
	InvalidOpaqueCaptureAddressError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), message)
	{}
	InvalidOpaqueCaptureAddressError(char const *message)
	    : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), message)
	{}
};

class SurfaceLostKHRError : public SystemError
{
public:
	SurfaceLostKHRError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message)
	{}
	SurfaceLostKHRError(char const *message)
	    : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message)
	{}
};

class NativeWindowInUseKHRError : public SystemError
{
public:
	NativeWindowInUseKHRError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message)
	{}
	NativeWindowInUseKHRError(char const *message)
	    : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message)
	{}
};

class OutOfDateKHRError : public SystemError
{
public:
	OutOfDateKHRError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message)
	{}
	OutOfDateKHRError(char const *message)
	    : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message)
	{}
};

class IncompatibleDisplayKHRError : public SystemError
{
public:
	IncompatibleDisplayKHRError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message)
	{}
	IncompatibleDisplayKHRError(char const *message)
	    : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message)
	{}
};

class ValidationFailedEXTError : public SystemError
{
public:
	ValidationFailedEXTError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message)
	{}
	ValidationFailedEXTError(char const *message)
	    : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message)
	{}
};

class InvalidShaderNVError : public SystemError
{
public:
	InvalidShaderNVError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message)
	{}
	InvalidShaderNVError(char const *message)
	    : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message)
	{}
};

class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
{
public:
	InvalidDrmFormatModifierPlaneLayoutEXTError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT), message)
	{
	}
	InvalidDrmFormatModifierPlaneLayoutEXTError(char const *message)
	    : SystemError(make_error_code(Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT), message)
	{
	}
};

class NotPermittedKHRError : public SystemError
{
public:
	NotPermittedKHRError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
	{}
	NotPermittedKHRError(char const *message)
	    : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
	{}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
class FullScreenExclusiveModeLostEXTError : public SystemError
{
public:
	FullScreenExclusiveModeLostEXTError(std::string const &message)
	    : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
	{
	}
	FullScreenExclusiveModeLostEXTError(char const *message)
	    : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
	{}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

namespace {
[[noreturn]] void throwResultException(Result result, char const *message)
{
	switch(result)
	{
	case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError(message);
	case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError(message);
	case Result::eErrorInitializationFailed: throw InitializationFailedError(message);
	case Result::eErrorDeviceLost: throw DeviceLostError(message);
	case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError(message);
	case Result::eErrorLayerNotPresent: throw LayerNotPresentError(message);
	case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError(message);
	case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError(message);
	case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError(message);
	case Result::eErrorTooManyObjects: throw TooManyObjectsError(message);
	case Result::eErrorFormatNotSupported: throw FormatNotSupportedError(message);
	case Result::eErrorFragmentedPool: throw FragmentedPoolError(message);
	case Result::eErrorUnknown: throw UnknownError(message);
	case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError(message);
	case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError(message);
	case Result::eErrorFragmentation: throw FragmentationError(message);
	case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError(message);
	case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError(message);
	case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError(message);
	case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError(message);
	case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError(message);
	case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError(message);
	case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError(message);
	case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError(message);
	case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError(message);
#	if defined(VK_USE_PLATFORM_WIN32_KHR)
	case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError(message);
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/
	default: throw SystemError(make_error_code(result));
	}
}
}  // namespace
#endif

template<typename T>
void ignore(T const &) VULKAN_HPP_NOEXCEPT
{
}

template<typename T>
struct ResultValue
{
#ifdef VULKAN_HPP_HAS_NOEXCEPT
	ResultValue(Result r, T &v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
#else
	ResultValue(Result r, T &v)
#endif
	    : result(r)
	    , value(v)
	{
	}

#ifdef VULKAN_HPP_HAS_NOEXCEPT
	ResultValue(Result r, T &&v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v))))
#else
	ResultValue(Result r, T &&v)
#endif
	    : result(r)
	    , value(std::move(v))
	{
	}

	Result result;
	T value;

	operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
	{
		return std::tuple<Result &, T &>(result, value);
	}

#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator T const &() const &VULKAN_HPP_NOEXCEPT
	{
		return value;
	}

	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator T &() & VULKAN_HPP_NOEXCEPT
	{
		return value;
	}

	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator T const &&() const &&VULKAN_HPP_NOEXCEPT
	{
		return std::move(value);
	}

	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator T &&() && VULKAN_HPP_NOEXCEPT
	{
		return std::move(value);
	}
#endif
};

#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
template<typename Type, typename Dispatch>
struct ResultValue<UniqueHandle<Type, Dispatch>>
{
#	ifdef VULKAN_HPP_HAS_NOEXCEPT
	ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v) VULKAN_HPP_NOEXCEPT
#	else
	ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v)
#	endif
	    : result(r),
	      value(std::move(v))
	{
	}

	std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
	{
		return std::make_tuple(result, std::move(value));
	}

#	if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator UniqueHandle<Type, Dispatch> &() & VULKAN_HPP_NOEXCEPT
	{
		return value;
	}

	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
	{
		return std::move(value);
	}
#	endif

	Result result;
	UniqueHandle<Type, Dispatch> value;
};

template<typename Type, typename Dispatch>
struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
{
#	ifdef VULKAN_HPP_HAS_NOEXCEPT
	ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v) VULKAN_HPP_NOEXCEPT
#	else
	ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v)
#	endif
	    : result(r),
	      value(std::move(v))
	{
	}

	std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
	{
		return std::make_tuple(result, std::move(value));
	}

	Result result;
	std::vector<UniqueHandle<Type, Dispatch>> value;

#	if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
	VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
	operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT
	{
		return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>(result, value);
	}
#	endif
};
#endif

template<typename T>
struct ResultValueType
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	typedef ResultValue<T> type;
#else
	typedef T type;
#endif
};

template<>
struct ResultValueType<void>
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	typedef Result type;
#else
	typedef void type;
#endif
};

template<typename T>
VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue(Result result, T &data, char const *message)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
	return ResultValue<T>(result, std::move(data));
#else
	if(result != Result::eSuccess)
	{
		throwResultException(result, message);
	}
	return std::move(data);
#endif
}

template<typename T>
VULKAN_HPP_INLINE ResultValue<T> createResultValue(Result result, T &data, char const *message, std::initializer_list<Result> successCodes)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
#else
	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
	{
		throwResultException(result, message);
	}
#endif
	return ResultValue<T>(result, std::move(data));
}

#ifndef VULKAN_HPP_NO_SMART_HANDLE
template<typename T, typename D>
VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T, D>>::type
createResultValue(Result result, T &data, char const *message, typename UniqueHandleTraits<T, D>::deleter const &deleter)
{
#	ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
	return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
#	else
	if(result != Result::eSuccess)
	{
		throwResultException(result, message);
	}
	return UniqueHandle<T, D>(data, deleter);
#	endif
}

template<typename T, typename D>
VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>> createResultValue(
    Result result, T &data, char const *message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T, D>::deleter const &deleter)
{
#	ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
#	else
	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
	{
		throwResultException(result, message);
	}
#	endif
	return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
}

template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>, Allocator>>::type
createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message)
{
#	ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
	return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
#	else
	if(result != Result::eSuccess)
	{
		throwResultException(result, message);
	}
	return std::move(data);
#	endif
}

template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>
createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message, std::initializer_list<Result> successCodes)
{
#	ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(message);
	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
#	else
	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
	{
		throwResultException(result, message);
	}
#	endif
	return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
}
#endif

template<typename T>
VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType(Result result, T &data)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	return ResultValue<T>(result, std::move(data));
#else
	ignore(result);
	return std::move(data);
#endif
}

VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType(Result result)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	return result;
#else
	ignore(result);
#endif
}

VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(result);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	ignore(message);
	VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
#else
	if(result != Result::eSuccess)
	{
		throwResultException(result, message);
	}
#endif
}

VULKAN_HPP_INLINE void resultCheck(Result result, char const *message, std::initializer_list<Result> successCodes)
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
	ignore(result);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	ignore(message);
	ignore(successCodes);  // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
	VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
#else
	if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
	{
		throwResultException(result, message);
	}
#endif
}
}  // namespace VULKAN_HPP_NAMESPACE

// clang-format off
#include <vulkan/vulkan_handles.hpp>
#include <vulkan/vulkan_structs.hpp>
#include <vulkan/vulkan_funcs.hpp>
// clang-format on

namespace VULKAN_HPP_NAMESPACE {
//=======================
//=== STRUCTS EXTENDS ===
//=======================

//=== VK_VERSION_1_0 ===
template<>
struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_VERSION_1_1 ===
template<>
struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_VERSION_1_2 ===
template<>
struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_VERSION_1_3 ===
template<>
struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryBarrier2, SubpassDependency2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<FormatProperties3, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_swapchain ===
template<>
struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_display_swapchain ===
template<>
struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_debug_report ===
template<>
struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_rasterization_order ===
template<>
struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_KHR_video_queue ===
template<>
struct StructExtends<QueueFamilyQueryResultStatusProperties2KHR, QueueFamilyProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoQueueFamilyProperties2KHR, QueueFamilyProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfileKHR, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfileKHR, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfileKHR, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfileKHR, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfileKHR, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfilesKHR, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfilesKHR, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfilesKHR, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoProfilesKHR, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_KHR_video_decode_queue ===
template<>
struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_NV_dedicated_allocation ===
template<>
struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_transform_feedback ===
template<>
struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_EXT_video_encode_h264 ===
template<>
struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoEncodeCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264VclFrameInfoEXT, VideoEncodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264EmitPictureParametersEXT, VideoEncodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, VideoProfileKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264ProfileEXT, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264RateControlInfoEXT, VideoEncodeRateControlInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_EXT_video_encode_h265 ===
template<>
struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoEncodeCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265VclFrameInfoEXT, VideoEncodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265EmitPictureParametersEXT, VideoEncodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, VideoProfileKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265ProfileEXT, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265RateControlInfoEXT, VideoEncodeRateControlInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_EXT_video_decode_h264 ===
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, VideoProfileKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264ProfileEXT, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264CapabilitiesEXT, VideoDecodeCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264PictureInfoEXT, VideoDecodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264MvcEXT, VideoDecodeH264PictureInfoEXT>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH264DpbSlotInfoEXT, VideoReferenceSlotKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_AMD_texture_gather_bias_lod ===
template<>
struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_dynamic_rendering ===
template<>
struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_corner_sampled_image ===
template<>
struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_external_memory ===
template<>
struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_NV_external_memory_win32 ===
template<>
struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_NV_win32_keyed_mutex ===
template<>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

//=== VK_EXT_validation_flags ===
template<>
struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_astc_decode_mode ===
template<>
struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_KHR_external_memory_win32 ===
template<>
struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

//=== VK_KHR_external_memory_fd ===
template<>
struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_KHR_win32_keyed_mutex ===
template<>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_KHR_external_semaphore_win32 ===
template<>
struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

//=== VK_KHR_push_descriptor ===
template<>
struct StructExtends<PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_conditional_rendering ===
template<>
struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_incremental_present ===
template<>
struct StructExtends<PresentRegionsKHR, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_clip_space_w_scaling ===
template<>
struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_display_control ===
template<>
struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_GOOGLE_display_timing ===
template<>
struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_NVX_multiview_per_view_attributes ===
template<>
struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_viewport_swizzle ===
template<>
struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_discard_rectangles ===
template<>
struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_conservative_rasterization ===
template<>
struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_depth_clip_enable ===
template<>
struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_shared_presentable_image ===
template<>
struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_KHR_external_fence_win32 ===
template<>
struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

//=== VK_KHR_performance_query ===
template<>
struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_debug_utils ===
template<>
struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
//=== VK_ANDROID_external_memory_android_hardware_buffer ===
template<>
struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExternalFormatANDROID, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

//=== VK_EXT_sample_locations ===
template<>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_blend_operation_advanced ===
template<>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_fragment_coverage_to_color ===
template<>
struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_acceleration_structure ===
template<>
struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_framebuffer_mixed_samples ===
template<>
struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_shader_sm_builtins ===
template<>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_image_drm_format_modifier ===
template<>
struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_validation_cache ===
template<>
struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_KHR_portability_subset ===
template<>
struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_NV_shading_rate_image ===
template<>
struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_ray_tracing ===
template<>
struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_representative_fragment_test ===
template<>
struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_filter_cubic ===
template<>
struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_external_memory_host ===
template<>
struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_shader_clock ===
template<>
struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_pipeline_compiler_control ===
template<>
struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_shader_core_properties ===
template<>
struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_EXT_video_decode_h265 ===
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, VideoProfileKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, FormatProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265ProfileEXT, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265CapabilitiesEXT, VideoDecodeCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265PictureInfoEXT, VideoDecodeInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoDecodeH265DpbSlotInfoEXT, VideoReferenceSlotKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_KHR_global_priority ===
template<>
struct StructExtends<DeviceQueueGlobalPriorityCreateInfoKHR, DeviceQueueCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<QueueFamilyGlobalPriorityPropertiesKHR, QueueFamilyProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_memory_overallocation_behavior ===
template<>
struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_vertex_attribute_divisor ===
template<>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_GGP)
//=== VK_GGP_frame_token ===
template<>
struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_GGP*/

//=== VK_NV_compute_shader_derivatives ===
template<>
struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_mesh_shader ===
template<>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_fragment_shader_barycentric ===
template<>
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_shader_image_footprint ===
template<>
struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_scissor_exclusive ===
template<>
struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_device_diagnostic_checkpoints ===
template<>
struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_INTEL_shader_integer_functions2 ===
template<>
struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_INTEL_performance_query ===
template<>
struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_pci_bus_info ===
template<>
struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_display_native_hdr ===
template<>
struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_fragment_density_map ===
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_fragment_shading_rate ===
template<>
struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_shader_core_properties2 ===
template<>
struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_AMD_device_coherent_memory ===
template<>
struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_shader_image_atomic_int64 ===
template<>
struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_memory_budget ===
template<>
struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_memory_priority ===
template<>
struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_surface_protected_capabilities ===
template<>
struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_dedicated_allocation_image_aliasing ===
template<>
struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_buffer_device_address ===
template<>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_validation_features ===
template<>
struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_present_wait ===
template<>
struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_cooperative_matrix ===
template<>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_coverage_reduction_mode ===
template<>
struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_fragment_shader_interlock ===
template<>
struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_ycbcr_image_arrays ===
template<>
struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_provoking_vertex ===
template<>
struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_WIN32_KHR)
//=== VK_EXT_full_screen_exclusive ===
template<>
struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

//=== VK_EXT_line_rasterization ===
template<>
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_shader_atomic_float ===
template<>
struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_index_type_uint8 ===
template<>
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_extended_dynamic_state ===
template<>
struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_pipeline_executable_properties ===
template<>
struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_shader_atomic_float2 ===
template<>
struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_device_generated_commands ===
template<>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_inherited_viewport_scissor ===
template<>
struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_texel_buffer_alignment ===
template<>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_QCOM_render_pass_transform ===
template<>
struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_device_memory_report ===
template<>
struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_robustness2 ===
template<>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_custom_border_color ===
template<>
struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_pipeline_library ===
template<>
struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_present_id ===
template<>
struct StructExtends<PresentIdKHR, PresentInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_KHR_video_encode_queue ===
template<>
struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<VideoEncodeRateControlLayerInfoKHR, VideoCodingControlInfoKHR>
{
	enum
	{
		value = true
	};
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_NV_device_diagnostics_config ===
template<>
struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_synchronization2 ===
template<>
struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_graphics_pipeline_library ===
template<>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<GraphicsPipelineLibraryCreateInfoEXT, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_shader_subgroup_uniform_control_flow ===
template<>
struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_fragment_shading_rate_enums ===
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_ray_tracing_motion_blur ===
template<>
struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, AccelerationStructureGeometryTrianglesDataKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_ycbcr_2plane_444_formats ===
template<>
struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_fragment_density_map2 ===
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_QCOM_rotated_copy_commands ===
template<>
struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_workgroup_memory_explicit_layout ===
template<>
struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_4444_formats ===
template<>
struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_ARM_rasterization_order_attachment_access ===
template<>
struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_rgba10x6_formats ===
template<>
struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_ray_tracing_pipeline ===
template<>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_KHR_ray_query ===
template<>
struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_VALVE_mutable_descriptor_type ===
template<>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_vertex_input_dynamic_state ===
template<>
struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_physical_device_drm ===
template<>
struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_depth_clip_control ===
template<>
struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_primitive_topology_list_restart ===
template<>
struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

#if defined(VK_USE_PLATFORM_FUCHSIA)
//=== VK_FUCHSIA_external_memory ===
template<>
struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
//=== VK_FUCHSIA_buffer_collection ===
template<>
struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo>
{
	enum
	{
		value = true
	};
};
#endif /*VK_USE_PLATFORM_FUCHSIA*/

//=== VK_HUAWEI_subpass_shading ===
template<>
struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_HUAWEI_invocation_mask ===
template<>
struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_external_memory_rdma ===
template<>
struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_extended_dynamic_state2 ===
template<>
struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_color_write_enable ===
template<>
struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_primitives_generated_query ===
template<>
struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_image_view_min_lod ===
template<>
struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_multi_draw ===
template<>
struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_image_2d_view_of_3d ===
template<>
struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_border_color_swizzle ===
template<>
struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_EXT_pageable_device_local_memory ===
template<>
struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_VALVE_descriptor_set_host_mapping ===
template<>
struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_QCOM_fragment_density_map_offset ===
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
{
	enum
	{
		value = true
	};
};

//=== VK_NV_linear_color_attachment ===
template<>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
{
	enum
	{
		value = true
	};
};
template<>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo>
{
	enum
	{
		value = true
	};
};

#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
class DynamicLoader
{
public:
#	ifdef VULKAN_HPP_NO_EXCEPTIONS
	DynamicLoader(std::string const &vulkanLibraryName = {}) VULKAN_HPP_NOEXCEPT
#	else
	DynamicLoader(std::string const &vulkanLibraryName = {})
#	endif
	{
		if(!vulkanLibraryName.empty())
		{
#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
			m_library = dlopen(vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL);
#	elif defined(_WIN32)
			m_library = ::LoadLibraryA(vulkanLibraryName.c_str());
#	else
#		error unsupported platform
#	endif
		}
		else
		{
#	if defined(__unix__) || defined(__QNXNTO__) || defined(__Fuchsia__)
			m_library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
			if(m_library == nullptr)
			{
				m_library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
			}
#	elif defined(__APPLE__)
			m_library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
#	elif defined(_WIN32)
			m_library = ::LoadLibraryA("vulkan-1.dll");
#	else
#		error unsupported platform
#	endif
		}

#	ifndef VULKAN_HPP_NO_EXCEPTIONS
		if(m_library == nullptr)
		{
			// NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
			throw std::runtime_error("Failed to load vulkan library!");
		}
#	endif
	}

	DynamicLoader(DynamicLoader const &) = delete;

	DynamicLoader(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT : m_library(other.m_library)
	{
		other.m_library = nullptr;
	}

	DynamicLoader &operator=(DynamicLoader const &) = delete;

	DynamicLoader &operator=(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT
	{
		std::swap(m_library, other.m_library);
		return *this;
	}

	~DynamicLoader() VULKAN_HPP_NOEXCEPT
	{
		if(m_library)
		{
#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
			dlclose(m_library);
#	elif defined(_WIN32)
			::FreeLibrary(m_library);
#	else
#		error unsupported platform
#	endif
		}
	}

	template<typename T>
	T getProcAddress(const char *function) const VULKAN_HPP_NOEXCEPT
	{
#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
		return (T)dlsym(m_library, function);
#	elif defined(_WIN32)
		return (T)::GetProcAddress(m_library, function);
#	else
#		error unsupported platform
#	endif
	}

	bool success() const VULKAN_HPP_NOEXCEPT
	{
		return m_library != nullptr;
	}

private:
#	if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
	void *m_library;
#	elif defined(_WIN32)
	::HINSTANCE m_library;
#	else
#		error unsupported platform
#	endif
};
#endif

using PFN_dummy = void (*)();

class DispatchLoaderDynamic : public DispatchLoaderBase
{
public:
	//=== VK_VERSION_1_0 ===
	PFN_vkCreateInstance vkCreateInstance = 0;
	PFN_vkDestroyInstance vkDestroyInstance = 0;
	PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
	PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
	PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0;
	PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0;
	PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
	PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
	PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
	PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
	PFN_vkCreateDevice vkCreateDevice = 0;
	PFN_vkDestroyDevice vkDestroyDevice = 0;
	PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
	PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
	PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
	PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
	PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
	PFN_vkQueueSubmit vkQueueSubmit = 0;
	PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
	PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
	PFN_vkAllocateMemory vkAllocateMemory = 0;
	PFN_vkFreeMemory vkFreeMemory = 0;
	PFN_vkMapMemory vkMapMemory = 0;
	PFN_vkUnmapMemory vkUnmapMemory = 0;
	PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
	PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
	PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
	PFN_vkBindBufferMemory vkBindBufferMemory = 0;
	PFN_vkBindImageMemory vkBindImageMemory = 0;
	PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
	PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
	PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0;
	PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0;
	PFN_vkQueueBindSparse vkQueueBindSparse = 0;
	PFN_vkCreateFence vkCreateFence = 0;
	PFN_vkDestroyFence vkDestroyFence = 0;
	PFN_vkResetFences vkResetFences = 0;
	PFN_vkGetFenceStatus vkGetFenceStatus = 0;
	PFN_vkWaitForFences vkWaitForFences = 0;
	PFN_vkCreateSemaphore vkCreateSemaphore = 0;
	PFN_vkDestroySemaphore vkDestroySemaphore = 0;
	PFN_vkCreateEvent vkCreateEvent = 0;
	PFN_vkDestroyEvent vkDestroyEvent = 0;
	PFN_vkGetEventStatus vkGetEventStatus = 0;
	PFN_vkSetEvent vkSetEvent = 0;
	PFN_vkResetEvent vkResetEvent = 0;
	PFN_vkCreateQueryPool vkCreateQueryPool = 0;
	PFN_vkDestroyQueryPool vkDestroyQueryPool = 0;
	PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
	PFN_vkCreateBuffer vkCreateBuffer = 0;
	PFN_vkDestroyBuffer vkDestroyBuffer = 0;
	PFN_vkCreateBufferView vkCreateBufferView = 0;
	PFN_vkDestroyBufferView vkDestroyBufferView = 0;
	PFN_vkCreateImage vkCreateImage = 0;
	PFN_vkDestroyImage vkDestroyImage = 0;
	PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
	PFN_vkCreateImageView vkCreateImageView = 0;
	PFN_vkDestroyImageView vkDestroyImageView = 0;
	PFN_vkCreateShaderModule vkCreateShaderModule = 0;
	PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
	PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
	PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
	PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
	PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
	PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
	PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
	PFN_vkDestroyPipeline vkDestroyPipeline = 0;
	PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
	PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0;
	PFN_vkCreateSampler vkCreateSampler = 0;
	PFN_vkDestroySampler vkDestroySampler = 0;
	PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
	PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
	PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
	PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
	PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
	PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
	PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
	PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
	PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
	PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0;
	PFN_vkCreateRenderPass vkCreateRenderPass = 0;
	PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
	PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
	PFN_vkCreateCommandPool vkCreateCommandPool = 0;
	PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
	PFN_vkResetCommandPool vkResetCommandPool = 0;
	PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
	PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
	PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
	PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
	PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
	PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
	PFN_vkCmdSetViewport vkCmdSetViewport = 0;
	PFN_vkCmdSetScissor vkCmdSetScissor = 0;
	PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
	PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
	PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
	PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
	PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0;
	PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
	PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
	PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
	PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
	PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
	PFN_vkCmdDraw vkCmdDraw = 0;
	PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
	PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
	PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
	PFN_vkCmdDispatch vkCmdDispatch = 0;
	PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
	PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
	PFN_vkCmdCopyImage vkCmdCopyImage = 0;
	PFN_vkCmdBlitImage vkCmdBlitImage = 0;
	PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
	PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0;
	PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
	PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
	PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
	PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
	PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
	PFN_vkCmdResolveImage vkCmdResolveImage = 0;
	PFN_vkCmdSetEvent vkCmdSetEvent = 0;
	PFN_vkCmdResetEvent vkCmdResetEvent = 0;
	PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
	PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
	PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
	PFN_vkCmdEndQuery vkCmdEndQuery = 0;
	PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0;
	PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
	PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
	PFN_vkCmdPushConstants vkCmdPushConstants = 0;
	PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
	PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
	PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
	PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;

	//=== VK_VERSION_1_1 ===
	PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
	PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
	PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
	PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
	PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
	PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
	PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
	PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
	PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
	PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
	PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
	PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
	PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0;
	PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0;
	PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
	PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
	PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
	PFN_vkTrimCommandPool vkTrimCommandPool = 0;
	PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
	PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
	PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
	PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
	PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
	PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
	PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0;
	PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0;
	PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
	PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;

	//=== VK_VERSION_1_2 ===
	PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
	PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
	PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
	PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
	PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
	PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
	PFN_vkResetQueryPool vkResetQueryPool = 0;
	PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
	PFN_vkWaitSemaphores vkWaitSemaphores = 0;
	PFN_vkSignalSemaphore vkSignalSemaphore = 0;
	PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
	PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
	PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;

	//=== VK_VERSION_1_3 ===
	PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0;
	PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0;
	PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0;
	PFN_vkSetPrivateData vkSetPrivateData = 0;
	PFN_vkGetPrivateData vkGetPrivateData = 0;
	PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0;
	PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0;
	PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0;
	PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0;
	PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0;
	PFN_vkQueueSubmit2 vkQueueSubmit2 = 0;
	PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0;
	PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0;
	PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0;
	PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0;
	PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0;
	PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0;
	PFN_vkCmdBeginRendering vkCmdBeginRendering = 0;
	PFN_vkCmdEndRendering vkCmdEndRendering = 0;
	PFN_vkCmdSetCullMode vkCmdSetCullMode = 0;
	PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0;
	PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0;
	PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0;
	PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0;
	PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0;
	PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0;
	PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0;
	PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0;
	PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0;
	PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0;
	PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0;
	PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0;
	PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0;
	PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0;
	PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0;
	PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0;
	PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;

	//=== VK_KHR_surface ===
	PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
	PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0;
	PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
	PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0;
	PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;

	//=== VK_KHR_swapchain ===
	PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
	PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0;
	PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
	PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
	PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
	PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
	PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0;
	PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
	PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;

	//=== VK_KHR_display ===
	PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
	PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
	PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
	PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
	PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
	PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
	PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;

	//=== VK_KHR_display_swapchain ===
	PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;

#if defined(VK_USE_PLATFORM_XLIB_KHR)
	//=== VK_KHR_xlib_surface ===
	PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
	PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
#else
	PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_XLIB_KHR*/

#if defined(VK_USE_PLATFORM_XCB_KHR)
	//=== VK_KHR_xcb_surface ===
	PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
	PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
#else
	PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_XCB_KHR*/

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
	//=== VK_KHR_wayland_surface ===
	PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
	PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
#else
	PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
	//=== VK_KHR_android_surface ===
	PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
#else
	PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_win32_surface ===
	PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
	PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
#else
	PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_EXT_debug_report ===
	PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
	PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
	PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;

	//=== VK_EXT_debug_marker ===
	PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
	PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
	PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0;
	PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
	PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;

#if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_queue ===
	PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0;
	PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0;
	PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0;
	PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0;
	PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0;
	PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0;
	PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0;
	PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0;
	PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0;
	PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0;
	PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0;
	PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0;
#else
	PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder = 0;
	PFN_dummy vkCreateVideoSessionKHR_placeholder = 0;
	PFN_dummy vkDestroyVideoSessionKHR_placeholder = 0;
	PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder = 0;
	PFN_dummy vkBindVideoSessionMemoryKHR_placeholder = 0;
	PFN_dummy vkCreateVideoSessionParametersKHR_placeholder = 0;
	PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder = 0;
	PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder = 0;
	PFN_dummy vkCmdBeginVideoCodingKHR_placeholder = 0;
	PFN_dummy vkCmdEndVideoCodingKHR_placeholder = 0;
	PFN_dummy vkCmdControlVideoCodingKHR_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_decode_queue ===
	PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0;
#else
	PFN_dummy vkCmdDecodeVideoKHR_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

	//=== VK_EXT_transform_feedback ===
	PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
	PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
	PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
	PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
	PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
	PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;

	//=== VK_NVX_binary_import ===
	PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0;
	PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0;
	PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0;
	PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
	PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;

	//=== VK_NVX_image_view_handle ===
	PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
	PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;

	//=== VK_AMD_draw_indirect_count ===
	PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
	PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;

	//=== VK_AMD_shader_info ===
	PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;

	//=== VK_KHR_dynamic_rendering ===
	PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0;
	PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0;

#if defined(VK_USE_PLATFORM_GGP)
	//=== VK_GGP_stream_descriptor_surface ===
	PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
#else
	PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0;
#endif /*VK_USE_PLATFORM_GGP*/

	//=== VK_NV_external_memory_capabilities ===
	PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_NV_external_memory_win32 ===
	PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
#else
	PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_get_physical_device_properties2 ===
	PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
	PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;

	//=== VK_KHR_device_group ===
	PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
	PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
	PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;

#if defined(VK_USE_PLATFORM_VI_NN)
	//=== VK_NN_vi_surface ===
	PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
#else
	PFN_dummy vkCreateViSurfaceNN_placeholder = 0;
#endif /*VK_USE_PLATFORM_VI_NN*/

	//=== VK_KHR_maintenance1 ===
	PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;

	//=== VK_KHR_device_group_creation ===
	PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;

	//=== VK_KHR_external_memory_capabilities ===
	PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_memory_win32 ===
	PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
	PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
#else
	PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0;
	PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_memory_fd ===
	PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0;
	PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;

	//=== VK_KHR_external_semaphore_capabilities ===
	PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_semaphore_win32 ===
	PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
	PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
#else
	PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0;
	PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_semaphore_fd ===
	PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
	PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;

	//=== VK_KHR_push_descriptor ===
	PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0;
	PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0;

	//=== VK_EXT_conditional_rendering ===
	PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
	PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;

	//=== VK_KHR_descriptor_update_template ===
	PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
	PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
	PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;

	//=== VK_NV_clip_space_w_scaling ===
	PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;

	//=== VK_EXT_direct_mode_display ===
	PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;

#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
	//=== VK_EXT_acquire_xlib_display ===
	PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
	PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
#else
	PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0;
	PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/

	//=== VK_EXT_display_surface_counter ===
	PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;

	//=== VK_EXT_display_control ===
	PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
	PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
	PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
	PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;

	//=== VK_GOOGLE_display_timing ===
	PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
	PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;

	//=== VK_EXT_discard_rectangles ===
	PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;

	//=== VK_EXT_hdr_metadata ===
	PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;

	//=== VK_KHR_create_renderpass2 ===
	PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
	PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
	PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
	PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;

	//=== VK_KHR_shared_presentable_image ===
	PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;

	//=== VK_KHR_external_fence_capabilities ===
	PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_KHR_external_fence_win32 ===
	PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
	PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
#else
	PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0;
	PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_KHR_external_fence_fd ===
	PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
	PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;

	//=== VK_KHR_performance_query ===
	PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
	PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
	PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
	PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;

	//=== VK_KHR_get_surface_capabilities2 ===
	PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
	PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0;

	//=== VK_KHR_get_display_properties2 ===
	PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
	PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
	PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
	PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;

#if defined(VK_USE_PLATFORM_IOS_MVK)
	//=== VK_MVK_ios_surface ===
	PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
#else
	PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0;
#endif /*VK_USE_PLATFORM_IOS_MVK*/

#if defined(VK_USE_PLATFORM_MACOS_MVK)
	//=== VK_MVK_macos_surface ===
	PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
#else
	PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0;
#endif /*VK_USE_PLATFORM_MACOS_MVK*/

	//=== VK_EXT_debug_utils ===
	PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
	PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
	PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
	PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
	PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
	PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
	PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
	PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
	PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
	PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
	PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
	//=== VK_ANDROID_external_memory_android_hardware_buffer ===
	PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
	PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
#else
	PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0;
	PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0;
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

	//=== VK_EXT_sample_locations ===
	PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
	PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;

	//=== VK_KHR_get_memory_requirements2 ===
	PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
	PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
	PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;

	//=== VK_KHR_acceleration_structure ===
	PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0;
	PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
	PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0;
	PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0;
	PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0;
	PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0;
	PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0;
	PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0;
	PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
	PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0;
	PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0;
	PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0;
	PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
	PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0;
	PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
	PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0;

	//=== VK_KHR_sampler_ycbcr_conversion ===
	PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
	PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;

	//=== VK_KHR_bind_memory2 ===
	PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
	PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;

	//=== VK_EXT_image_drm_format_modifier ===
	PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;

	//=== VK_EXT_validation_cache ===
	PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
	PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
	PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
	PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;

	//=== VK_NV_shading_rate_image ===
	PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
	PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
	PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;

	//=== VK_NV_ray_tracing ===
	PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
	PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
	PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
	PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
	PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0;
	PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0;
	PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0;
	PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
	PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
	PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
	PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
	PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;

	//=== VK_KHR_maintenance3 ===
	PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;

	//=== VK_KHR_draw_indirect_count ===
	PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
	PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;

	//=== VK_EXT_external_memory_host ===
	PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;

	//=== VK_AMD_buffer_marker ===
	PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;

	//=== VK_EXT_calibrated_timestamps ===
	PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
	PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;

	//=== VK_NV_mesh_shader ===
	PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
	PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
	PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;

	//=== VK_NV_scissor_exclusive ===
	PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;

	//=== VK_NV_device_diagnostic_checkpoints ===
	PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
	PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;

	//=== VK_KHR_timeline_semaphore ===
	PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
	PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
	PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;

	//=== VK_INTEL_performance_query ===
	PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0;
	PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
	PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
	PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0;
	PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
	PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
	PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
	PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
	PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;

	//=== VK_AMD_display_native_hdr ===
	PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;

#if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_imagepipe_surface ===
	PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
#else
	PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_METAL_EXT)
	//=== VK_EXT_metal_surface ===
	PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
#else
	PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/

	//=== VK_KHR_fragment_shading_rate ===
	PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
	PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;

	//=== VK_EXT_buffer_device_address ===
	PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;

	//=== VK_EXT_tooling_info ===
	PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0;

	//=== VK_KHR_present_wait ===
	PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0;

	//=== VK_NV_cooperative_matrix ===
	PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;

	//=== VK_NV_coverage_reduction_mode ===
	PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_EXT_full_screen_exclusive ===
	PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
	PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
	PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
	PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
#else
	PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0;
	PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0;
	PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0;
	PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

	//=== VK_EXT_headless_surface ===
	PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;

	//=== VK_KHR_buffer_device_address ===
	PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0;
	PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
	PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;

	//=== VK_EXT_line_rasterization ===
	PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;

	//=== VK_EXT_host_query_reset ===
	PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;

	//=== VK_EXT_extended_dynamic_state ===
	PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0;
	PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0;
	PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0;
	PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0;
	PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0;
	PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0;
	PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
	PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
	PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
	PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
	PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0;
	PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0;

	//=== VK_KHR_deferred_host_operations ===
	PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
	PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
	PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
	PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
	PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;

	//=== VK_KHR_pipeline_executable_properties ===
	PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
	PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
	PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;

	//=== VK_NV_device_generated_commands ===
	PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
	PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0;
	PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0;
	PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0;
	PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0;
	PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0;

	//=== VK_EXT_acquire_drm_display ===
	PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0;
	PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0;

	//=== VK_EXT_private_data ===
	PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0;
	PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0;
	PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0;
	PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0;

#if defined(VK_ENABLE_BETA_EXTENSIONS)
	//=== VK_KHR_video_encode_queue ===
	PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0;
#else
	PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

	//=== VK_KHR_synchronization2 ===
	PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
	PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0;
	PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0;
	PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
	PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0;
	PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0;
	PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
	PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;

	//=== VK_NV_fragment_shading_rate_enums ===
	PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;

	//=== VK_KHR_copy_commands2 ===
	PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
	PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
	PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
	PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
	PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
	PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
	//=== VK_NV_acquire_winrt_display ===
	PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
	PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
#else
	PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
	PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
	//=== VK_EXT_directfb_surface ===
	PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
	PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
#else
	PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/

	//=== VK_KHR_ray_tracing_pipeline ===
	PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0;
	PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
	PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
	PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
	PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0;
	PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0;
	PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0;

	//=== VK_EXT_vertex_input_dynamic_state ===
	PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;

#if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_external_memory ===
	PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0;
	PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
#else
	PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0;
	PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_external_semaphore ===
	PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
	PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0;
#else
	PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0;
	PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
	//=== VK_FUCHSIA_buffer_collection ===
	PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0;
	PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
	PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
	PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0;
	PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0;
#else
	PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0;
	PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0;
	PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0;
	PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0;
	PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0;
#endif /*VK_USE_PLATFORM_FUCHSIA*/

	//=== VK_HUAWEI_subpass_shading ===
	PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0;
	PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0;

	//=== VK_HUAWEI_invocation_mask ===
	PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0;

	//=== VK_NV_external_memory_rdma ===
	PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0;

	//=== VK_EXT_extended_dynamic_state2 ===
	PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0;
	PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
	PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0;
	PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0;
	PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0;

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
	//=== VK_QNX_screen_surface ===
	PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
	PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
#else
	PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0;
	PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/

	//=== VK_EXT_color_write_enable ===
	PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;

	//=== VK_EXT_multi_draw ===
	PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0;
	PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0;

	//=== VK_EXT_pageable_device_local_memory ===
	PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0;

	//=== VK_KHR_maintenance4 ===
	PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0;
	PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0;
	PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0;

	//=== VK_VALVE_descriptor_set_host_mapping ===
	PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0;
	PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0;

public:
	DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
	DispatchLoaderDynamic(DispatchLoaderDynamic const &rhs) VULKAN_HPP_NOEXCEPT = default;

#if !defined(VK_NO_PROTOTYPES)
	// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
	template<typename DynamicLoader>
	void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device, DynamicLoader const &dl) VULKAN_HPP_NOEXCEPT
	{
		PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
		PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>("vkGetDeviceProcAddr");
		init(static_cast<VkInstance>(instance), getInstanceProcAddr, static_cast<VkDevice>(device), device ? getDeviceProcAddr : nullptr);
	}

	// This interface is designed to be used for per-device function pointers in combination with a linked vulkan library.
	template<typename DynamicLoader
#	if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
	         = VULKAN_HPP_NAMESPACE::DynamicLoader
#	endif
	         >
	void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device) VULKAN_HPP_NOEXCEPT
	{
		static DynamicLoader dl;
		init(instance, device, dl);
	}
#endif  // !defined( VK_NO_PROTOTYPES )

	DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
	{
		init(getInstanceProcAddr);
	}

	void init(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(getInstanceProcAddr);

		vkGetInstanceProcAddr = getInstanceProcAddr;

		//=== VK_VERSION_1_0 ===
		vkCreateInstance = PFN_vkCreateInstance(vkGetInstanceProcAddr(NULL, "vkCreateInstance"));
		vkEnumerateInstanceExtensionProperties =
		    PFN_vkEnumerateInstanceExtensionProperties(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties"));
		vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceLayerProperties"));

		//=== VK_VERSION_1_1 ===
		vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion"));
	}

	// This interface does not require a linked vulkan library.
	DispatchLoaderDynamic(VkInstance instance,
	                      PFN_vkGetInstanceProcAddr getInstanceProcAddr,
	                      VkDevice device = {},
	                      PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr) VULKAN_HPP_NOEXCEPT
	{
		init(instance, getInstanceProcAddr, device, getDeviceProcAddr);
	}

	// This interface does not require a linked vulkan library.
	void init(VkInstance instance,
	          PFN_vkGetInstanceProcAddr getInstanceProcAddr,
	          VkDevice device = {},
	          PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr) VULKAN_HPP_NOEXCEPT
	{
		VULKAN_HPP_ASSERT(instance && getInstanceProcAddr);
		vkGetInstanceProcAddr = getInstanceProcAddr;
		init(VULKAN_HPP_NAMESPACE::Instance(instance));
		if(device)
		{
			init(VULKAN_HPP_NAMESPACE::Device(device));
		}
	}

	void init(VULKAN_HPP_NAMESPACE::Instance instanceCpp) VULKAN_HPP_NOEXCEPT
	{
		VkInstance instance = static_cast<VkInstance>(instanceCpp);

		//=== VK_VERSION_1_0 ===
		vkDestroyInstance = PFN_vkDestroyInstance(vkGetInstanceProcAddr(instance, "vkDestroyInstance"));
		vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices"));
		vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures"));
		vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties"));
		vkGetPhysicalDeviceImageFormatProperties =
		    PFN_vkGetPhysicalDeviceImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
		vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties"));
		vkGetPhysicalDeviceQueueFamilyProperties =
		    PFN_vkGetPhysicalDeviceQueueFamilyProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
		vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties"));
		vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr"));
		vkCreateDevice = PFN_vkCreateDevice(vkGetInstanceProcAddr(instance, "vkCreateDevice"));
		vkDestroyDevice = PFN_vkDestroyDevice(vkGetInstanceProcAddr(instance, "vkDestroyDevice"));
		vkEnumerateDeviceExtensionProperties =
		    PFN_vkEnumerateDeviceExtensionProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties"));
		vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties"));
		vkGetDeviceQueue = PFN_vkGetDeviceQueue(vkGetInstanceProcAddr(instance, "vkGetDeviceQueue"));
		vkQueueSubmit = PFN_vkQueueSubmit(vkGetInstanceProcAddr(instance, "vkQueueSubmit"));
		vkQueueWaitIdle = PFN_vkQueueWaitIdle(vkGetInstanceProcAddr(instance, "vkQueueWaitIdle"));
		vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(vkGetInstanceProcAddr(instance, "vkDeviceWaitIdle"));
		vkAllocateMemory = PFN_vkAllocateMemory(vkGetInstanceProcAddr(instance, "vkAllocateMemory"));
		vkFreeMemory = PFN_vkFreeMemory(vkGetInstanceProcAddr(instance, "vkFreeMemory"));
		vkMapMemory = PFN_vkMapMemory(vkGetInstanceProcAddr(instance, "vkMapMemory"));
		vkUnmapMemory = PFN_vkUnmapMemory(vkGetInstanceProcAddr(instance, "vkUnmapMemory"));
		vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(vkGetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges"));
		vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(vkGetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges"));
		vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment"));
		vkBindBufferMemory = PFN_vkBindBufferMemory(vkGetInstanceProcAddr(instance, "vkBindBufferMemory"));
		vkBindImageMemory = PFN_vkBindImageMemory(vkGetInstanceProcAddr(instance, "vkBindImageMemory"));
		vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements"));
		vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements"));
		vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements"));
		vkGetPhysicalDeviceSparseImageFormatProperties =
		    PFN_vkGetPhysicalDeviceSparseImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
		vkQueueBindSparse = PFN_vkQueueBindSparse(vkGetInstanceProcAddr(instance, "vkQueueBindSparse"));
		vkCreateFence = PFN_vkCreateFence(vkGetInstanceProcAddr(instance, "vkCreateFence"));
		vkDestroyFence = PFN_vkDestroyFence(vkGetInstanceProcAddr(instance, "vkDestroyFence"));
		vkResetFences = PFN_vkResetFences(vkGetInstanceProcAddr(instance, "vkResetFences"));
		vkGetFenceStatus = PFN_vkGetFenceStatus(vkGetInstanceProcAddr(instance, "vkGetFenceStatus"));
		vkWaitForFences = PFN_vkWaitForFences(vkGetInstanceProcAddr(instance, "vkWaitForFences"));
		vkCreateSemaphore = PFN_vkCreateSemaphore(vkGetInstanceProcAddr(instance, "vkCreateSemaphore"));
		vkDestroySemaphore = PFN_vkDestroySemaphore(vkGetInstanceProcAddr(instance, "vkDestroySemaphore"));
		vkCreateEvent = PFN_vkCreateEvent(vkGetInstanceProcAddr(instance, "vkCreateEvent"));
		vkDestroyEvent = PFN_vkDestroyEvent(vkGetInstanceProcAddr(instance, "vkDestroyEvent"));
		vkGetEventStatus = PFN_vkGetEventStatus(vkGetInstanceProcAddr(instance, "vkGetEventStatus"));
		vkSetEvent = PFN_vkSetEvent(vkGetInstanceProcAddr(instance, "vkSetEvent"));
		vkResetEvent = PFN_vkResetEvent(vkGetInstanceProcAddr(instance, "vkResetEvent"));
		vkCreateQueryPool = PFN_vkCreateQueryPool(vkGetInstanceProcAddr(instance, "vkCreateQueryPool"));
		vkDestroyQueryPool = PFN_vkDestroyQueryPool(vkGetInstanceProcAddr(instance, "vkDestroyQueryPool"));
		vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(vkGetInstanceProcAddr(instance, "vkGetQueryPoolResults"));
		vkCreateBuffer = PFN_vkCreateBuffer(vkGetInstanceProcAddr(instance, "vkCreateBuffer"));
		vkDestroyBuffer = PFN_vkDestroyBuffer(vkGetInstanceProcAddr(instance, "vkDestroyBuffer"));
		vkCreateBufferView = PFN_vkCreateBufferView(vkGetInstanceProcAddr(instance, "vkCreateBufferView"));
		vkDestroyBufferView = PFN_vkDestroyBufferView(vkGetInstanceProcAddr(instance, "vkDestroyBufferView"));
		vkCreateImage = PFN_vkCreateImage(vkGetInstanceProcAddr(instance, "vkCreateImage"));
		vkDestroyImage = PFN_vkDestroyImage(vkGetInstanceProcAddr(instance, "vkDestroyImage"));
		vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout"));
		vkCreateImageView = PFN_vkCreateImageView(vkGetInstanceProcAddr(instance, "vkCreateImageView"));
		vkDestroyImageView = PFN_vkDestroyImageView(vkGetInstanceProcAddr(instance, "vkDestroyImageView"));
		vkCreateShaderModule = PFN_vkCreateShaderModule(vkGetInstanceProcAddr(instance, "vkCreateShaderModule"));
		vkDestroyShaderModule = PFN_vkDestroyShaderModule(vkGetInstanceProcAddr(instance, "vkDestroyShaderModule"));
		vkCreatePipelineCache = PFN_vkCreatePipelineCache(vkGetInstanceProcAddr(instance, "vkCreatePipelineCache"));
		vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(vkGetInstanceProcAddr(instance, "vkDestroyPipelineCache"));
		vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(vkGetInstanceProcAddr(instance, "vkGetPipelineCacheData"));
		vkMergePipelineCaches = PFN_vkMergePipelineCaches(vkGetInstanceProcAddr(instance, "vkMergePipelineCaches"));
		vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(vkGetInstanceProcAddr(instance, "vkCreateGraphicsPipelines"));
		vkCreateComputePipelines = PFN_vkCreateComputePipelines(vkGetInstanceProcAddr(instance, "vkCreateComputePipelines"));
		vkDestroyPipeline = PFN_vkDestroyPipeline(vkGetInstanceProcAddr(instance, "vkDestroyPipeline"));
		vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(vkGetInstanceProcAddr(instance, "vkCreatePipelineLayout"));
		vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(vkGetInstanceProcAddr(instance, "vkDestroyPipelineLayout"));
		vkCreateSampler = PFN_vkCreateSampler(vkGetInstanceProcAddr(instance, "vkCreateSampler"));
		vkDestroySampler = PFN_vkDestroySampler(vkGetInstanceProcAddr(instance, "vkDestroySampler"));
		vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(vkGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout"));
		vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout"));
		vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(vkGetInstanceProcAddr(instance, "vkCreateDescriptorPool"));
		vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorPool"));
		vkResetDescriptorPool = PFN_vkResetDescriptorPool(vkGetInstanceProcAddr(instance, "vkResetDescriptorPool"));
		vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(vkGetInstanceProcAddr(instance, "vkAllocateDescriptorSets"));
		vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(vkGetInstanceProcAddr(instance, "vkFreeDescriptorSets"));
		vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSets"));
		vkCreateFramebuffer = PFN_vkCreateFramebuffer(vkGetInstanceProcAddr(instance, "vkCreateFramebuffer"));
		vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(vkGetInstanceProcAddr(instance, "vkDestroyFramebuffer"));
		vkCreateRenderPass = PFN_vkCreateRenderPass(vkGetInstanceProcAddr(instance, "vkCreateRenderPass"));
		vkDestroyRenderPass = PFN_vkDestroyRenderPass(vkGetInstanceProcAddr(instance, "vkDestroyRenderPass"));
		vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(vkGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity"));
		vkCreateCommandPool = PFN_vkCreateCommandPool(vkGetInstanceProcAddr(instance, "vkCreateCommandPool"));
		vkDestroyCommandPool = PFN_vkDestroyCommandPool(vkGetInstanceProcAddr(instance, "vkDestroyCommandPool"));
		vkResetCommandPool = PFN_vkResetCommandPool(vkGetInstanceProcAddr(instance, "vkResetCommandPool"));
		vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(vkGetInstanceProcAddr(instance, "vkAllocateCommandBuffers"));
		vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(vkGetInstanceProcAddr(instance, "vkFreeCommandBuffers"));
		vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(vkGetInstanceProcAddr(instance, "vkBeginCommandBuffer"));
		vkEndCommandBuffer = PFN_vkEndCommandBuffer(vkGetInstanceProcAddr(instance, "vkEndCommandBuffer"));
		vkResetCommandBuffer = PFN_vkResetCommandBuffer(vkGetInstanceProcAddr(instance, "vkResetCommandBuffer"));
		vkCmdBindPipeline = PFN_vkCmdBindPipeline(vkGetInstanceProcAddr(instance, "vkCmdBindPipeline"));
		vkCmdSetViewport = PFN_vkCmdSetViewport(vkGetInstanceProcAddr(instance, "vkCmdSetViewport"));
		vkCmdSetScissor = PFN_vkCmdSetScissor(vkGetInstanceProcAddr(instance, "vkCmdSetScissor"));
		vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(vkGetInstanceProcAddr(instance, "vkCmdSetLineWidth"));
		vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBias"));
		vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(vkGetInstanceProcAddr(instance, "vkCmdSetBlendConstants"));
		vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBounds"));
		vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(vkGetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask"));
		vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(vkGetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask"));
		vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(vkGetInstanceProcAddr(instance, "vkCmdSetStencilReference"));
		vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorSets"));
		vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(vkGetInstanceProcAddr(instance, "vkCmdBindIndexBuffer"));
		vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers"));
		vkCmdDraw = PFN_vkCmdDraw(vkGetInstanceProcAddr(instance, "vkCmdDraw"));
		vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexed"));
		vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirect"));
		vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect"));
		vkCmdDispatch = PFN_vkCmdDispatch(vkGetInstanceProcAddr(instance, "vkCmdDispatch"));
		vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(vkGetInstanceProcAddr(instance, "vkCmdDispatchIndirect"));
		vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer"));
		vkCmdCopyImage = PFN_vkCmdCopyImage(vkGetInstanceProcAddr(instance, "vkCmdCopyImage"));
		vkCmdBlitImage = PFN_vkCmdBlitImage(vkGetInstanceProcAddr(instance, "vkCmdBlitImage"));
		vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage"));
		vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer"));
		vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(vkGetInstanceProcAddr(instance, "vkCmdUpdateBuffer"));
		vkCmdFillBuffer = PFN_vkCmdFillBuffer(vkGetInstanceProcAddr(instance, "vkCmdFillBuffer"));
		vkCmdClearColorImage = PFN_vkCmdClearColorImage(vkGetInstanceProcAddr(instance, "vkCmdClearColorImage"));
		vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(vkGetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage"));
		vkCmdClearAttachments = PFN_vkCmdClearAttachments(vkGetInstanceProcAddr(instance, "vkCmdClearAttachments"));
		vkCmdResolveImage = PFN_vkCmdResolveImage(vkGetInstanceProcAddr(instance, "vkCmdResolveImage"));
		vkCmdSetEvent = PFN_vkCmdSetEvent(vkGetInstanceProcAddr(instance, "vkCmdSetEvent"));
		vkCmdResetEvent = PFN_vkCmdResetEvent(vkGetInstanceProcAddr(instance, "vkCmdResetEvent"));
		vkCmdWaitEvents = PFN_vkCmdWaitEvents(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents"));
		vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier"));
		vkCmdBeginQuery = PFN_vkCmdBeginQuery(vkGetInstanceProcAddr(instance, "vkCmdBeginQuery"));
		vkCmdEndQuery = PFN_vkCmdEndQuery(vkGetInstanceProcAddr(instance, "vkCmdEndQuery"));
		vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(vkGetInstanceProcAddr(instance, "vkCmdResetQueryPool"));
		vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp"));
		vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(vkGetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults"));
		vkCmdPushConstants = PFN_vkCmdPushConstants(vkGetInstanceProcAddr(instance, "vkCmdPushConstants"));
		vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass"));
		vkCmdNextSubpass = PFN_vkCmdNextSubpass(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass"));
		vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass"));
		vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(vkGetInstanceProcAddr(instance, "vkCmdExecuteCommands"));

		//=== VK_VERSION_1_1 ===
		vkBindBufferMemory2 = PFN_vkBindBufferMemory2(vkGetInstanceProcAddr(instance, "vkBindBufferMemory2"));
		vkBindImageMemory2 = PFN_vkBindImageMemory2(vkGetInstanceProcAddr(instance, "vkBindImageMemory2"));
		vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures"));
		vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMask"));
		vkCmdDispatchBase = PFN_vkCmdDispatchBase(vkGetInstanceProcAddr(instance, "vkCmdDispatchBase"));
		vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups"));
		vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2"));
		vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2"));
		vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2"));
		vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"));
		vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"));
		vkGetPhysicalDeviceFormatProperties2 =
		    PFN_vkGetPhysicalDeviceFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2"));
		vkGetPhysicalDeviceImageFormatProperties2 =
		    PFN_vkGetPhysicalDeviceImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2"));
		vkGetPhysicalDeviceQueueFamilyProperties2 =
		    PFN_vkGetPhysicalDeviceQueueFamilyProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"));
		vkGetPhysicalDeviceMemoryProperties2 =
		    PFN_vkGetPhysicalDeviceMemoryProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2"));
		vkGetPhysicalDeviceSparseImageFormatProperties2 =
		    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"));
		vkTrimCommandPool = PFN_vkTrimCommandPool(vkGetInstanceProcAddr(instance, "vkTrimCommandPool"));
		vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(vkGetInstanceProcAddr(instance, "vkGetDeviceQueue2"));
		vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion"));
		vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion"));
		vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate"));
		vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate"));
		vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate"));
		vkGetPhysicalDeviceExternalBufferProperties =
		    PFN_vkGetPhysicalDeviceExternalBufferProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties"));
		vkGetPhysicalDeviceExternalFenceProperties =
		    PFN_vkGetPhysicalDeviceExternalFenceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties"));
		vkGetPhysicalDeviceExternalSemaphoreProperties =
		    PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"));
		vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport"));

		//=== VK_VERSION_1_2 ===
		vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCount"));
		vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount"));
		vkCreateRenderPass2 = PFN_vkCreateRenderPass2(vkGetInstanceProcAddr(instance, "vkCreateRenderPass2"));
		vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2"));
		vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2"));
		vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2"));
		vkResetQueryPool = PFN_vkResetQueryPool(vkGetInstanceProcAddr(instance, "vkResetQueryPool"));
		vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue"));
		vkWaitSemaphores = PFN_vkWaitSemaphores(vkGetInstanceProcAddr(instance, "vkWaitSemaphores"));
		vkSignalSemaphore = PFN_vkSignalSemaphore(vkGetInstanceProcAddr(instance, "vkSignalSemaphore"));
		vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddress"));
		vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress"));
		vkGetDeviceMemoryOpaqueCaptureAddress =
		    PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress"));

		//=== VK_VERSION_1_3 ===
		vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties"));
		vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot(vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlot"));
		vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot(vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot"));
		vkSetPrivateData = PFN_vkSetPrivateData(vkGetInstanceProcAddr(instance, "vkSetPrivateData"));
		vkGetPrivateData = PFN_vkGetPrivateData(vkGetInstanceProcAddr(instance, "vkGetPrivateData"));
		vkCmdSetEvent2 = PFN_vkCmdSetEvent2(vkGetInstanceProcAddr(instance, "vkCmdSetEvent2"));
		vkCmdResetEvent2 = PFN_vkCmdResetEvent2(vkGetInstanceProcAddr(instance, "vkCmdResetEvent2"));
		vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2"));
		vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2"));
		vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2"));
		vkQueueSubmit2 = PFN_vkQueueSubmit2(vkGetInstanceProcAddr(instance, "vkQueueSubmit2"));
		vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2"));
		vkCmdCopyImage2 = PFN_vkCmdCopyImage2(vkGetInstanceProcAddr(instance, "vkCmdCopyImage2"));
		vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2"));
		vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2"));
		vkCmdBlitImage2 = PFN_vkCmdBlitImage2(vkGetInstanceProcAddr(instance, "vkCmdBlitImage2"));
		vkCmdResolveImage2 = PFN_vkCmdResolveImage2(vkGetInstanceProcAddr(instance, "vkCmdResolveImage2"));
		vkCmdBeginRendering = PFN_vkCmdBeginRendering(vkGetInstanceProcAddr(instance, "vkCmdBeginRendering"));
		vkCmdEndRendering = PFN_vkCmdEndRendering(vkGetInstanceProcAddr(instance, "vkCmdEndRendering"));
		vkCmdSetCullMode = PFN_vkCmdSetCullMode(vkGetInstanceProcAddr(instance, "vkCmdSetCullMode"));
		vkCmdSetFrontFace = PFN_vkCmdSetFrontFace(vkGetInstanceProcAddr(instance, "vkCmdSetFrontFace"));
		vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology"));
		vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCount"));
		vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount(vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCount"));
		vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2"));
		vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable"));
		vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable"));
		vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp(vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp"));
		vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable"));
		vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable"));
		vkCmdSetStencilOp = PFN_vkCmdSetStencilOp(vkGetInstanceProcAddr(instance, "vkCmdSetStencilOp"));
		vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable(vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable"));
		vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable"));
		vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable"));
		vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements"));
		vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements"));
		vkGetDeviceImageSparseMemoryRequirements =
		    PFN_vkGetDeviceImageSparseMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements"));

		//=== VK_KHR_surface ===
		vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
		vkGetPhysicalDeviceSurfaceSupportKHR =
		    PFN_vkGetPhysicalDeviceSurfaceSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
		vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
		    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
		vkGetPhysicalDeviceSurfaceFormatsKHR =
		    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
		vkGetPhysicalDeviceSurfacePresentModesKHR =
		    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));

		//=== VK_KHR_swapchain ===
		vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(vkGetInstanceProcAddr(instance, "vkCreateSwapchainKHR"));
		vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(vkGetInstanceProcAddr(instance, "vkDestroySwapchainKHR"));
		vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(vkGetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR"));
		vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(vkGetInstanceProcAddr(instance, "vkAcquireNextImageKHR"));
		vkQueuePresentKHR = PFN_vkQueuePresentKHR(vkGetInstanceProcAddr(instance, "vkQueuePresentKHR"));
		vkGetDeviceGroupPresentCapabilitiesKHR =
		    PFN_vkGetDeviceGroupPresentCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR"));
		vkGetDeviceGroupSurfacePresentModesKHR =
		    PFN_vkGetDeviceGroupSurfacePresentModesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR"));
		vkGetPhysicalDevicePresentRectanglesKHR =
		    PFN_vkGetPhysicalDevicePresentRectanglesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR"));
		vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(vkGetInstanceProcAddr(instance, "vkAcquireNextImage2KHR"));

		//=== VK_KHR_display ===
		vkGetPhysicalDeviceDisplayPropertiesKHR =
		    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR"));
		vkGetPhysicalDeviceDisplayPlanePropertiesKHR =
		    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
		vkGetDisplayPlaneSupportedDisplaysKHR =
		    PFN_vkGetDisplayPlaneSupportedDisplaysKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR"));
		vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR"));
		vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR"));
		vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR"));
		vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR"));

		//=== VK_KHR_display_swapchain ===
		vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(vkGetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR"));

#if defined(VK_USE_PLATFORM_XLIB_KHR)
		//=== VK_KHR_xlib_surface ===
		vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR"));
		vkGetPhysicalDeviceXlibPresentationSupportKHR =
		    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_XLIB_KHR*/

#if defined(VK_USE_PLATFORM_XCB_KHR)
		//=== VK_KHR_xcb_surface ===
		vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR"));
		vkGetPhysicalDeviceXcbPresentationSupportKHR =
		    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_XCB_KHR*/

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
		//=== VK_KHR_wayland_surface ===
		vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR"));
		vkGetPhysicalDeviceWaylandPresentationSupportKHR =
		    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
		//=== VK_KHR_android_surface ===
		vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR"));
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_win32_surface ===
		vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR"));
		vkGetPhysicalDeviceWin32PresentationSupportKHR =
		    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_EXT_debug_report ===
		vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT"));
		vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT"));
		vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(vkGetInstanceProcAddr(instance, "vkDebugReportMessageEXT"));

		//=== VK_EXT_debug_marker ===
		vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(vkGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectTagEXT"));
		vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(vkGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectNameEXT"));
		vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerBeginEXT"));
		vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerEndEXT"));
		vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT"));

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_queue ===
		vkGetPhysicalDeviceVideoCapabilitiesKHR =
		    PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR"));
		vkGetPhysicalDeviceVideoFormatPropertiesKHR =
		    PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"));
		vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR(vkGetInstanceProcAddr(instance, "vkCreateVideoSessionKHR"));
		vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR(vkGetInstanceProcAddr(instance, "vkDestroyVideoSessionKHR"));
		vkGetVideoSessionMemoryRequirementsKHR =
		    PFN_vkGetVideoSessionMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetVideoSessionMemoryRequirementsKHR"));
		vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR(vkGetInstanceProcAddr(instance, "vkBindVideoSessionMemoryKHR"));
		vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkCreateVideoSessionParametersKHR"));
		vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkUpdateVideoSessionParametersKHR"));
		vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkDestroyVideoSessionParametersKHR"));
		vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdBeginVideoCodingKHR"));
		vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdEndVideoCodingKHR"));
		vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdControlVideoCodingKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_decode_queue ===
		vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR(vkGetInstanceProcAddr(instance, "vkCmdDecodeVideoKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

		//=== VK_EXT_transform_feedback ===
		vkCmdBindTransformFeedbackBuffersEXT =
		    PFN_vkCmdBindTransformFeedbackBuffersEXT(vkGetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT"));
		vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT"));
		vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(vkGetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT"));
		vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT"));
		vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT"));
		vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT"));

		//=== VK_NVX_binary_import ===
		vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX(vkGetInstanceProcAddr(instance, "vkCreateCuModuleNVX"));
		vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX(vkGetInstanceProcAddr(instance, "vkCreateCuFunctionNVX"));
		vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX(vkGetInstanceProcAddr(instance, "vkDestroyCuModuleNVX"));
		vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX(vkGetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX"));
		vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX(vkGetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX"));

		//=== VK_NVX_image_view_handle ===
		vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX(vkGetInstanceProcAddr(instance, "vkGetImageViewHandleNVX"));
		vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX(vkGetInstanceProcAddr(instance, "vkGetImageViewAddressNVX"));

		//=== VK_AMD_draw_indirect_count ===
		vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD"));
		if(!vkCmdDrawIndirectCount)
			vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
		vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD"));
		if(!vkCmdDrawIndexedIndirectCount)
			vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;

		//=== VK_AMD_shader_info ===
		vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(vkGetInstanceProcAddr(instance, "vkGetShaderInfoAMD"));

		//=== VK_KHR_dynamic_rendering ===
		vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderingKHR"));
		if(!vkCmdBeginRendering)
			vkCmdBeginRendering = vkCmdBeginRenderingKHR;
		vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR(vkGetInstanceProcAddr(instance, "vkCmdEndRenderingKHR"));
		if(!vkCmdEndRendering)
			vkCmdEndRendering = vkCmdEndRenderingKHR;

#if defined(VK_USE_PLATFORM_GGP)
		//=== VK_GGP_stream_descriptor_surface ===
		vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP(vkGetInstanceProcAddr(instance, "vkCreateStreamDescriptorSurfaceGGP"));
#endif /*VK_USE_PLATFORM_GGP*/

		//=== VK_NV_external_memory_capabilities ===
		vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
		    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"));

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_NV_external_memory_win32 ===
		vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandleNV"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_get_physical_device_properties2 ===
		vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));
		if(!vkGetPhysicalDeviceFeatures2)
			vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
		vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"));
		if(!vkGetPhysicalDeviceProperties2)
			vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
		vkGetPhysicalDeviceFormatProperties2KHR =
		    PFN_vkGetPhysicalDeviceFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR"));
		if(!vkGetPhysicalDeviceFormatProperties2)
			vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR;
		vkGetPhysicalDeviceImageFormatProperties2KHR =
		    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR"));
		if(!vkGetPhysicalDeviceImageFormatProperties2)
			vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR;
		vkGetPhysicalDeviceQueueFamilyProperties2KHR =
		    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
		if(!vkGetPhysicalDeviceQueueFamilyProperties2)
			vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR;
		vkGetPhysicalDeviceMemoryProperties2KHR =
		    PFN_vkGetPhysicalDeviceMemoryProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR"));
		if(!vkGetPhysicalDeviceMemoryProperties2)
			vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR;
		vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
		    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"));
		if(!vkGetPhysicalDeviceSparseImageFormatProperties2)
			vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR;

		//=== VK_KHR_device_group ===
		vkGetDeviceGroupPeerMemoryFeaturesKHR =
		    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR"));
		if(!vkGetDeviceGroupPeerMemoryFeatures)
			vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
		vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR"));
		if(!vkCmdSetDeviceMask)
			vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
		vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(vkGetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR"));
		if(!vkCmdDispatchBase)
			vkCmdDispatchBase = vkCmdDispatchBaseKHR;

#if defined(VK_USE_PLATFORM_VI_NN)
		//=== VK_NN_vi_surface ===
		vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(vkGetInstanceProcAddr(instance, "vkCreateViSurfaceNN"));
#endif /*VK_USE_PLATFORM_VI_NN*/

		//=== VK_KHR_maintenance1 ===
		vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(vkGetInstanceProcAddr(instance, "vkTrimCommandPoolKHR"));
		if(!vkTrimCommandPool)
			vkTrimCommandPool = vkTrimCommandPoolKHR;

		//=== VK_KHR_device_group_creation ===
		vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR"));
		if(!vkEnumeratePhysicalDeviceGroups)
			vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;

		//=== VK_KHR_external_memory_capabilities ===
		vkGetPhysicalDeviceExternalBufferPropertiesKHR =
		    PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"));
		if(!vkGetPhysicalDeviceExternalBufferProperties)
			vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_memory_win32 ===
		vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandleKHR"));
		vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandlePropertiesKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_memory_fd ===
		vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryFdKHR"));
		vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR"));

		//=== VK_KHR_external_semaphore_capabilities ===
		vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
		    PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"));
		if(!vkGetPhysicalDeviceExternalSemaphoreProperties)
			vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_semaphore_win32 ===
		vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkImportSemaphoreWin32HandleKHR"));
		vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreWin32HandleKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_semaphore_fd ===
		vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(vkGetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR"));
		vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR"));

		//=== VK_KHR_push_descriptor ===
		vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR"));
		vkCmdPushDescriptorSetWithTemplateKHR =
		    PFN_vkCmdPushDescriptorSetWithTemplateKHR(vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR"));

		//=== VK_EXT_conditional_rendering ===
		vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT"));
		vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(vkGetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT"));

		//=== VK_KHR_descriptor_update_template ===
		vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplateKHR"));
		if(!vkCreateDescriptorUpdateTemplate)
			vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
		vkDestroyDescriptorUpdateTemplateKHR =
		    PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplateKHR"));
		if(!vkDestroyDescriptorUpdateTemplate)
			vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
		vkUpdateDescriptorSetWithTemplateKHR =
		    PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplateKHR"));
		if(!vkUpdateDescriptorSetWithTemplate)
			vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;

		//=== VK_NV_clip_space_w_scaling ===
		vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV"));

		//=== VK_EXT_direct_mode_display ===
		vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT"));

#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
		//=== VK_EXT_acquire_xlib_display ===
		vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT"));
		vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT"));
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/

		//=== VK_EXT_display_surface_counter ===
		vkGetPhysicalDeviceSurfaceCapabilities2EXT =
		    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));

		//=== VK_EXT_display_control ===
		vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(vkGetInstanceProcAddr(instance, "vkDisplayPowerControlEXT"));
		vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(vkGetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT"));
		vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(vkGetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT"));
		vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(vkGetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT"));

		//=== VK_GOOGLE_display_timing ===
		vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(vkGetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE"));
		vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(vkGetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE"));

		//=== VK_EXT_discard_rectangles ===
		vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT"));

		//=== VK_EXT_hdr_metadata ===
		vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(vkGetInstanceProcAddr(instance, "vkSetHdrMetadataEXT"));

		//=== VK_KHR_create_renderpass2 ===
		vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCreateRenderPass2KHR"));
		if(!vkCreateRenderPass2)
			vkCreateRenderPass2 = vkCreateRenderPass2KHR;
		vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR"));
		if(!vkCmdBeginRenderPass2)
			vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
		vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR"));
		if(!vkCmdNextSubpass2)
			vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
		vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR"));
		if(!vkCmdEndRenderPass2)
			vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;

		//=== VK_KHR_shared_presentable_image ===
		vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(vkGetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR"));

		//=== VK_KHR_external_fence_capabilities ===
		vkGetPhysicalDeviceExternalFencePropertiesKHR =
		    PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
		if(!vkGetPhysicalDeviceExternalFenceProperties)
			vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_fence_win32 ===
		vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkImportFenceWin32HandleKHR"));
		vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetFenceWin32HandleKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_fence_fd ===
		vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(vkGetInstanceProcAddr(instance, "vkImportFenceFdKHR"));
		vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(vkGetInstanceProcAddr(instance, "vkGetFenceFdKHR"));

		//=== VK_KHR_performance_query ===
		vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
		    vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"));
		vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
		    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"));
		vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR(vkGetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR"));
		vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR(vkGetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR"));

		//=== VK_KHR_get_surface_capabilities2 ===
		vkGetPhysicalDeviceSurfaceCapabilities2KHR =
		    PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"));
		vkGetPhysicalDeviceSurfaceFormats2KHR =
		    PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR"));

		//=== VK_KHR_get_display_properties2 ===
		vkGetPhysicalDeviceDisplayProperties2KHR =
		    PFN_vkGetPhysicalDeviceDisplayProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR"));
		vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
		    PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"));
		vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModeProperties2KHR"));
		vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilities2KHR"));

#if defined(VK_USE_PLATFORM_IOS_MVK)
		//=== VK_MVK_ios_surface ===
		vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateIOSSurfaceMVK"));
#endif /*VK_USE_PLATFORM_IOS_MVK*/

#if defined(VK_USE_PLATFORM_MACOS_MVK)
		//=== VK_MVK_macos_surface ===
		vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK"));
#endif /*VK_USE_PLATFORM_MACOS_MVK*/

		//=== VK_EXT_debug_utils ===
		vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"));
		vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT"));
		vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT"));
		vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT"));
		vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT"));
		vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT"));
		vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT"));
		vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT"));
		vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"));
		vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"));
		vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT"));

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
		//=== VK_ANDROID_external_memory_android_hardware_buffer ===
		vkGetAndroidHardwareBufferPropertiesANDROID =
		    PFN_vkGetAndroidHardwareBufferPropertiesANDROID(vkGetInstanceProcAddr(instance, "vkGetAndroidHardwareBufferPropertiesANDROID"));
		vkGetMemoryAndroidHardwareBufferANDROID =
		    PFN_vkGetMemoryAndroidHardwareBufferANDROID(vkGetInstanceProcAddr(instance, "vkGetMemoryAndroidHardwareBufferANDROID"));
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

		//=== VK_EXT_sample_locations ===
		vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT"));
		vkGetPhysicalDeviceMultisamplePropertiesEXT =
		    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"));

		//=== VK_KHR_get_memory_requirements2 ===
		vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR"));
		if(!vkGetImageMemoryRequirements2)
			vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
		vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR"));
		if(!vkGetBufferMemoryRequirements2)
			vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
		vkGetImageSparseMemoryRequirements2KHR =
		    PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2KHR"));
		if(!vkGetImageSparseMemoryRequirements2)
			vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;

		//=== VK_KHR_acceleration_structure ===
		vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR"));
		vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR"));
		vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR"));
		vkCmdBuildAccelerationStructuresIndirectKHR =
		    PFN_vkCmdBuildAccelerationStructuresIndirectKHR(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR"));
		vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(vkGetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR"));
		vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR"));
		vkCopyAccelerationStructureToMemoryKHR =
		    PFN_vkCopyAccelerationStructureToMemoryKHR(vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR"));
		vkCopyMemoryToAccelerationStructureKHR =
		    PFN_vkCopyMemoryToAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR"));
		vkWriteAccelerationStructuresPropertiesKHR =
		    PFN_vkWriteAccelerationStructuresPropertiesKHR(vkGetInstanceProcAddr(instance, "vkWriteAccelerationStructuresPropertiesKHR"));
		vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR"));
		vkCmdCopyAccelerationStructureToMemoryKHR =
		    PFN_vkCmdCopyAccelerationStructureToMemoryKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR"));
		vkCmdCopyMemoryToAccelerationStructureKHR =
		    PFN_vkCmdCopyMemoryToAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR"));
		vkGetAccelerationStructureDeviceAddressKHR =
		    PFN_vkGetAccelerationStructureDeviceAddressKHR(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR"));
		vkCmdWriteAccelerationStructuresPropertiesKHR =
		    PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR"));
		vkGetDeviceAccelerationStructureCompatibilityKHR =
		    PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR"));
		vkGetAccelerationStructureBuildSizesKHR =
		    PFN_vkGetAccelerationStructureBuildSizesKHR(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR"));

		//=== VK_KHR_sampler_ycbcr_conversion ===
		vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR"));
		if(!vkCreateSamplerYcbcrConversion)
			vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
		vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR"));
		if(!vkDestroySamplerYcbcrConversion)
			vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;

		//=== VK_KHR_bind_memory2 ===
		vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(vkGetInstanceProcAddr(instance, "vkBindBufferMemory2KHR"));
		if(!vkBindBufferMemory2)
			vkBindBufferMemory2 = vkBindBufferMemory2KHR;
		vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(vkGetInstanceProcAddr(instance, "vkBindImageMemory2KHR"));
		if(!vkBindImageMemory2)
			vkBindImageMemory2 = vkBindImageMemory2KHR;

		//=== VK_EXT_image_drm_format_modifier ===
		vkGetImageDrmFormatModifierPropertiesEXT =
		    PFN_vkGetImageDrmFormatModifierPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT"));

		//=== VK_EXT_validation_cache ===
		vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(vkGetInstanceProcAddr(instance, "vkCreateValidationCacheEXT"));
		vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(vkGetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT"));
		vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(vkGetInstanceProcAddr(instance, "vkMergeValidationCachesEXT"));
		vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(vkGetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT"));

		//=== VK_NV_shading_rate_image ===
		vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(vkGetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV"));
		vkCmdSetViewportShadingRatePaletteNV =
		    PFN_vkCmdSetViewportShadingRatePaletteNV(vkGetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV"));
		vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(vkGetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV"));

		//=== VK_NV_ray_tracing ===
		vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV"));
		vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV"));
		vkGetAccelerationStructureMemoryRequirementsNV =
		    PFN_vkGetAccelerationStructureMemoryRequirementsNV(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV"));
		vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(vkGetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV"));
		vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV"));
		vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV"));
		vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysNV"));
		vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV"));
		vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesNV"));
		if(!vkGetRayTracingShaderGroupHandlesKHR)
			vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
		vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV"));
		vkCmdWriteAccelerationStructuresPropertiesNV =
		    PFN_vkCmdWriteAccelerationStructuresPropertiesNV(vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV"));
		vkCompileDeferredNV = PFN_vkCompileDeferredNV(vkGetInstanceProcAddr(instance, "vkCompileDeferredNV"));

		//=== VK_KHR_maintenance3 ===
		vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR"));
		if(!vkGetDescriptorSetLayoutSupport)
			vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;

		//=== VK_KHR_draw_indirect_count ===
		vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR"));
		if(!vkCmdDrawIndirectCount)
			vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
		vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR"));
		if(!vkCmdDrawIndexedIndirectCount)
			vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;

		//=== VK_EXT_external_memory_host ===
		vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT"));

		//=== VK_AMD_buffer_marker ===
		vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD"));

		//=== VK_EXT_calibrated_timestamps ===
		vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
		    PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"));
		vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(vkGetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT"));

		//=== VK_NV_mesh_shader ===
		vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV"));
		vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV"));
		vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV"));

		//=== VK_NV_scissor_exclusive ===
		vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV"));

		//=== VK_NV_device_diagnostic_checkpoints ===
		vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(vkGetInstanceProcAddr(instance, "vkCmdSetCheckpointNV"));
		vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV"));

		//=== VK_KHR_timeline_semaphore ===
		vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR"));
		if(!vkGetSemaphoreCounterValue)
			vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
		vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(vkGetInstanceProcAddr(instance, "vkWaitSemaphoresKHR"));
		if(!vkWaitSemaphores)
			vkWaitSemaphores = vkWaitSemaphoresKHR;
		vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(vkGetInstanceProcAddr(instance, "vkSignalSemaphoreKHR"));
		if(!vkSignalSemaphore)
			vkSignalSemaphore = vkSignalSemaphoreKHR;

		//=== VK_INTEL_performance_query ===
		vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL(vkGetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL"));
		vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL(vkGetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL"));
		vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL"));
		vkCmdSetPerformanceStreamMarkerINTEL =
		    PFN_vkCmdSetPerformanceStreamMarkerINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL"));
		vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL"));
		vkAcquirePerformanceConfigurationINTEL =
		    PFN_vkAcquirePerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL"));
		vkReleasePerformanceConfigurationINTEL =
		    PFN_vkReleasePerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL"));
		vkQueueSetPerformanceConfigurationINTEL =
		    PFN_vkQueueSetPerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL"));
		vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL(vkGetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL"));

		//=== VK_AMD_display_native_hdr ===
		vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD(vkGetInstanceProcAddr(instance, "vkSetLocalDimmingAMD"));

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_imagepipe_surface ===
		vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(vkGetInstanceProcAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_METAL_EXT)
		//=== VK_EXT_metal_surface ===
		vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateMetalSurfaceEXT"));
#endif /*VK_USE_PLATFORM_METAL_EXT*/

		//=== VK_KHR_fragment_shading_rate ===
		vkGetPhysicalDeviceFragmentShadingRatesKHR =
		    PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
		vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR(vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR"));

		//=== VK_EXT_buffer_device_address ===
		vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT"));
		if(!vkGetBufferDeviceAddress)
			vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;

		//=== VK_EXT_tooling_info ===
		vkGetPhysicalDeviceToolPropertiesEXT =
		    PFN_vkGetPhysicalDeviceToolPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT"));
		if(!vkGetPhysicalDeviceToolProperties)
			vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT;

		//=== VK_KHR_present_wait ===
		vkWaitForPresentKHR = PFN_vkWaitForPresentKHR(vkGetInstanceProcAddr(instance, "vkWaitForPresentKHR"));

		//=== VK_NV_cooperative_matrix ===
		vkGetPhysicalDeviceCooperativeMatrixPropertiesNV =
		    PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"));

		//=== VK_NV_coverage_reduction_mode ===
		vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
		    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"));

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_EXT_full_screen_exclusive ===
		vkGetPhysicalDeviceSurfacePresentModes2EXT =
		    PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT"));
		vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(vkGetInstanceProcAddr(instance, "vkAcquireFullScreenExclusiveModeEXT"));
		vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(vkGetInstanceProcAddr(instance, "vkReleaseFullScreenExclusiveModeEXT"));
		vkGetDeviceGroupSurfacePresentModes2EXT =
		    PFN_vkGetDeviceGroupSurfacePresentModes2EXT(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModes2EXT"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_EXT_headless_surface ===
		vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT"));

		//=== VK_KHR_buffer_device_address ===
		vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR"));
		if(!vkGetBufferDeviceAddress)
			vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
		vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR"));
		if(!vkGetBufferOpaqueCaptureAddress)
			vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
		vkGetDeviceMemoryOpaqueCaptureAddressKHR =
		    PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
		if(!vkGetDeviceMemoryOpaqueCaptureAddress)
			vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;

		//=== VK_EXT_line_rasterization ===
		vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT(vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT"));

		//=== VK_EXT_host_query_reset ===
		vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(vkGetInstanceProcAddr(instance, "vkResetQueryPoolEXT"));
		if(!vkResetQueryPool)
			vkResetQueryPool = vkResetQueryPoolEXT;

		//=== VK_EXT_extended_dynamic_state ===
		vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT(vkGetInstanceProcAddr(instance, "vkCmdSetCullModeEXT"));
		if(!vkCmdSetCullMode)
			vkCmdSetCullMode = vkCmdSetCullModeEXT;
		vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT(vkGetInstanceProcAddr(instance, "vkCmdSetFrontFaceEXT"));
		if(!vkCmdSetFrontFace)
			vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
		vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopologyEXT"));
		if(!vkCmdSetPrimitiveTopology)
			vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
		vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCountEXT"));
		if(!vkCmdSetViewportWithCount)
			vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
		vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT(vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCountEXT"));
		if(!vkCmdSetScissorWithCount)
			vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
		vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2EXT"));
		if(!vkCmdBindVertexBuffers2)
			vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
		vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnableEXT"));
		if(!vkCmdSetDepthTestEnable)
			vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
		vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnableEXT"));
		if(!vkCmdSetDepthWriteEnable)
			vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
		vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOpEXT"));
		if(!vkCmdSetDepthCompareOp)
			vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
		vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnableEXT"));
		if(!vkCmdSetDepthBoundsTestEnable)
			vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
		vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnableEXT"));
		if(!vkCmdSetStencilTestEnable)
			vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
		vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT"));
		if(!vkCmdSetStencilOp)
			vkCmdSetStencilOp = vkCmdSetStencilOpEXT;

		//=== VK_KHR_deferred_host_operations ===
		vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR(vkGetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR"));
		vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR(vkGetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR"));
		vkGetDeferredOperationMaxConcurrencyKHR =
		    PFN_vkGetDeferredOperationMaxConcurrencyKHR(vkGetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR"));
		vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(vkGetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR"));
		vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR(vkGetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR"));

		//=== VK_KHR_pipeline_executable_properties ===
		vkGetPipelineExecutablePropertiesKHR =
		    PFN_vkGetPipelineExecutablePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR"));
		vkGetPipelineExecutableStatisticsKHR =
		    PFN_vkGetPipelineExecutableStatisticsKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR"));
		vkGetPipelineExecutableInternalRepresentationsKHR =
		    PFN_vkGetPipelineExecutableInternalRepresentationsKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR"));

		//=== VK_NV_device_generated_commands ===
		vkGetGeneratedCommandsMemoryRequirementsNV =
		    PFN_vkGetGeneratedCommandsMemoryRequirementsNV(vkGetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV"));
		vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(vkGetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV"));
		vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV(vkGetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV"));
		vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV(vkGetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV"));
		vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV(vkGetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV"));
		vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV(vkGetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV"));

		//=== VK_EXT_acquire_drm_display ===
		vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT"));
		vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT"));

		//=== VK_EXT_private_data ===
		vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT(vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlotEXT"));
		if(!vkCreatePrivateDataSlot)
			vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
		vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT(vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlotEXT"));
		if(!vkDestroyPrivateDataSlot)
			vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
		vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(vkGetInstanceProcAddr(instance, "vkSetPrivateDataEXT"));
		if(!vkSetPrivateData)
			vkSetPrivateData = vkSetPrivateDataEXT;
		vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT(vkGetInstanceProcAddr(instance, "vkGetPrivateDataEXT"));
		if(!vkGetPrivateData)
			vkGetPrivateData = vkGetPrivateDataEXT;

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_encode_queue ===
		vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR(vkGetInstanceProcAddr(instance, "vkCmdEncodeVideoKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

		//=== VK_KHR_synchronization2 ===
		vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR(vkGetInstanceProcAddr(instance, "vkCmdSetEvent2KHR"));
		if(!vkCmdSetEvent2)
			vkCmdSetEvent2 = vkCmdSetEvent2KHR;
		vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR(vkGetInstanceProcAddr(instance, "vkCmdResetEvent2KHR"));
		if(!vkCmdResetEvent2)
			vkCmdResetEvent2 = vkCmdResetEvent2KHR;
		vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2KHR"));
		if(!vkCmdWaitEvents2)
			vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
		vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2KHR"));
		if(!vkCmdPipelineBarrier2)
			vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
		vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2KHR"));
		if(!vkCmdWriteTimestamp2)
			vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
		vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR(vkGetInstanceProcAddr(instance, "vkQueueSubmit2KHR"));
		if(!vkQueueSubmit2)
			vkQueueSubmit2 = vkQueueSubmit2KHR;
		vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD(vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarker2AMD"));
		vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV(vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointData2NV"));

		//=== VK_NV_fragment_shading_rate_enums ===
		vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV(vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV"));

		//=== VK_KHR_copy_commands2 ===
		vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2KHR"));
		if(!vkCmdCopyBuffer2)
			vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
		vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyImage2KHR"));
		if(!vkCmdCopyImage2)
			vkCmdCopyImage2 = vkCmdCopyImage2KHR;
		vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2KHR"));
		if(!vkCmdCopyBufferToImage2)
			vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
		vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2KHR"));
		if(!vkCmdCopyImageToBuffer2)
			vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
		vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdBlitImage2KHR"));
		if(!vkCmdBlitImage2)
			vkCmdBlitImage2 = vkCmdBlitImage2KHR;
		vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdResolveImage2KHR"));
		if(!vkCmdResolveImage2)
			vkCmdResolveImage2 = vkCmdResolveImage2KHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_NV_acquire_winrt_display ===
		vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkAcquireWinrtDisplayNV"));
		vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkGetWinrtDisplayNV"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
		//=== VK_EXT_directfb_surface ===
		vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateDirectFBSurfaceEXT"));
		vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
		    PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT"));
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/

		//=== VK_KHR_ray_tracing_pipeline ===
		vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysKHR"));
		vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR(vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesKHR"));
		vkGetRayTracingShaderGroupHandlesKHR =
		    PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR"));
		vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
		    PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"));
		vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR"));
		vkGetRayTracingShaderGroupStackSizeKHR =
		    PFN_vkGetRayTracingShaderGroupStackSizeKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR"));
		vkCmdSetRayTracingPipelineStackSizeKHR =
		    PFN_vkCmdSetRayTracingPipelineStackSizeKHR(vkGetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR"));

		//=== VK_EXT_vertex_input_dynamic_state ===
		vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT(vkGetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT"));

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_external_memory ===
		vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetMemoryZirconHandleFUCHSIA"));
		vkGetMemoryZirconHandlePropertiesFUCHSIA =
		    PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_external_semaphore ===
		vkImportSemaphoreZirconHandleFUCHSIA =
		    PFN_vkImportSemaphoreZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkImportSemaphoreZirconHandleFUCHSIA"));
		vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetSemaphoreZirconHandleFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_buffer_collection ===
		vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(vkGetInstanceProcAddr(instance, "vkCreateBufferCollectionFUCHSIA"));
		vkSetBufferCollectionImageConstraintsFUCHSIA =
		    PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetInstanceProcAddr(instance, "vkSetBufferCollectionImageConstraintsFUCHSIA"));
		vkSetBufferCollectionBufferConstraintsFUCHSIA =
		    PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(vkGetInstanceProcAddr(instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA"));
		vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(vkGetInstanceProcAddr(instance, "vkDestroyBufferCollectionFUCHSIA"));
		vkGetBufferCollectionPropertiesFUCHSIA =
		    PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetBufferCollectionPropertiesFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

		//=== VK_HUAWEI_subpass_shading ===
		vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
		    PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(vkGetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"));
		vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI(vkGetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI"));

		//=== VK_HUAWEI_invocation_mask ===
		vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI(vkGetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI"));

		//=== VK_NV_external_memory_rdma ===
		vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV(vkGetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV"));

		//=== VK_EXT_extended_dynamic_state2 ===
		vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPatchControlPointsEXT"));
		vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnableEXT"));
		if(!vkCmdSetRasterizerDiscardEnable)
			vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
		vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnableEXT"));
		if(!vkCmdSetDepthBiasEnable)
			vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
		vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetLogicOpEXT"));
		vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnableEXT"));
		if(!vkCmdSetPrimitiveRestartEnable)
			vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
		//=== VK_QNX_screen_surface ===
		vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX(vkGetInstanceProcAddr(instance, "vkCreateScreenSurfaceQNX"));
		vkGetPhysicalDeviceScreenPresentationSupportQNX =
		    PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX"));
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/

		//=== VK_EXT_color_write_enable ===
		vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteEnableEXT"));

		//=== VK_EXT_multi_draw ===
		vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawMultiEXT"));
		vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT"));

		//=== VK_EXT_pageable_device_local_memory ===
		vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT(vkGetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT"));

		//=== VK_KHR_maintenance4 ===
		vkGetDeviceBufferMemoryRequirementsKHR =
		    PFN_vkGetDeviceBufferMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirementsKHR"));
		if(!vkGetDeviceBufferMemoryRequirements)
			vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
		vkGetDeviceImageMemoryRequirementsKHR =
		    PFN_vkGetDeviceImageMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirementsKHR"));
		if(!vkGetDeviceImageMemoryRequirements)
			vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
		vkGetDeviceImageSparseMemoryRequirementsKHR =
		    PFN_vkGetDeviceImageSparseMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirementsKHR"));
		if(!vkGetDeviceImageSparseMemoryRequirements)
			vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;

		//=== VK_VALVE_descriptor_set_host_mapping ===
		vkGetDescriptorSetLayoutHostMappingInfoVALVE =
		    PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE"));
		vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE"));
	}

	void init(VULKAN_HPP_NAMESPACE::Device deviceCpp) VULKAN_HPP_NOEXCEPT
	{
		VkDevice device = static_cast<VkDevice>(deviceCpp);

		//=== VK_VERSION_1_0 ===
		vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetDeviceProcAddr(device, "vkGetDeviceProcAddr"));
		vkDestroyDevice = PFN_vkDestroyDevice(vkGetDeviceProcAddr(device, "vkDestroyDevice"));
		vkGetDeviceQueue = PFN_vkGetDeviceQueue(vkGetDeviceProcAddr(device, "vkGetDeviceQueue"));
		vkQueueSubmit = PFN_vkQueueSubmit(vkGetDeviceProcAddr(device, "vkQueueSubmit"));
		vkQueueWaitIdle = PFN_vkQueueWaitIdle(vkGetDeviceProcAddr(device, "vkQueueWaitIdle"));
		vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(vkGetDeviceProcAddr(device, "vkDeviceWaitIdle"));
		vkAllocateMemory = PFN_vkAllocateMemory(vkGetDeviceProcAddr(device, "vkAllocateMemory"));
		vkFreeMemory = PFN_vkFreeMemory(vkGetDeviceProcAddr(device, "vkFreeMemory"));
		vkMapMemory = PFN_vkMapMemory(vkGetDeviceProcAddr(device, "vkMapMemory"));
		vkUnmapMemory = PFN_vkUnmapMemory(vkGetDeviceProcAddr(device, "vkUnmapMemory"));
		vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkFlushMappedMemoryRanges"));
		vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges"));
		vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment"));
		vkBindBufferMemory = PFN_vkBindBufferMemory(vkGetDeviceProcAddr(device, "vkBindBufferMemory"));
		vkBindImageMemory = PFN_vkBindImageMemory(vkGetDeviceProcAddr(device, "vkBindImageMemory"));
		vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements"));
		vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements"));
		vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements"));
		vkQueueBindSparse = PFN_vkQueueBindSparse(vkGetDeviceProcAddr(device, "vkQueueBindSparse"));
		vkCreateFence = PFN_vkCreateFence(vkGetDeviceProcAddr(device, "vkCreateFence"));
		vkDestroyFence = PFN_vkDestroyFence(vkGetDeviceProcAddr(device, "vkDestroyFence"));
		vkResetFences = PFN_vkResetFences(vkGetDeviceProcAddr(device, "vkResetFences"));
		vkGetFenceStatus = PFN_vkGetFenceStatus(vkGetDeviceProcAddr(device, "vkGetFenceStatus"));
		vkWaitForFences = PFN_vkWaitForFences(vkGetDeviceProcAddr(device, "vkWaitForFences"));
		vkCreateSemaphore = PFN_vkCreateSemaphore(vkGetDeviceProcAddr(device, "vkCreateSemaphore"));
		vkDestroySemaphore = PFN_vkDestroySemaphore(vkGetDeviceProcAddr(device, "vkDestroySemaphore"));
		vkCreateEvent = PFN_vkCreateEvent(vkGetDeviceProcAddr(device, "vkCreateEvent"));
		vkDestroyEvent = PFN_vkDestroyEvent(vkGetDeviceProcAddr(device, "vkDestroyEvent"));
		vkGetEventStatus = PFN_vkGetEventStatus(vkGetDeviceProcAddr(device, "vkGetEventStatus"));
		vkSetEvent = PFN_vkSetEvent(vkGetDeviceProcAddr(device, "vkSetEvent"));
		vkResetEvent = PFN_vkResetEvent(vkGetDeviceProcAddr(device, "vkResetEvent"));
		vkCreateQueryPool = PFN_vkCreateQueryPool(vkGetDeviceProcAddr(device, "vkCreateQueryPool"));
		vkDestroyQueryPool = PFN_vkDestroyQueryPool(vkGetDeviceProcAddr(device, "vkDestroyQueryPool"));
		vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(vkGetDeviceProcAddr(device, "vkGetQueryPoolResults"));
		vkCreateBuffer = PFN_vkCreateBuffer(vkGetDeviceProcAddr(device, "vkCreateBuffer"));
		vkDestroyBuffer = PFN_vkDestroyBuffer(vkGetDeviceProcAddr(device, "vkDestroyBuffer"));
		vkCreateBufferView = PFN_vkCreateBufferView(vkGetDeviceProcAddr(device, "vkCreateBufferView"));
		vkDestroyBufferView = PFN_vkDestroyBufferView(vkGetDeviceProcAddr(device, "vkDestroyBufferView"));
		vkCreateImage = PFN_vkCreateImage(vkGetDeviceProcAddr(device, "vkCreateImage"));
		vkDestroyImage = PFN_vkDestroyImage(vkGetDeviceProcAddr(device, "vkDestroyImage"));
		vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(vkGetDeviceProcAddr(device, "vkGetImageSubresourceLayout"));
		vkCreateImageView = PFN_vkCreateImageView(vkGetDeviceProcAddr(device, "vkCreateImageView"));
		vkDestroyImageView = PFN_vkDestroyImageView(vkGetDeviceProcAddr(device, "vkDestroyImageView"));
		vkCreateShaderModule = PFN_vkCreateShaderModule(vkGetDeviceProcAddr(device, "vkCreateShaderModule"));
		vkDestroyShaderModule = PFN_vkDestroyShaderModule(vkGetDeviceProcAddr(device, "vkDestroyShaderModule"));
		vkCreatePipelineCache = PFN_vkCreatePipelineCache(vkGetDeviceProcAddr(device, "vkCreatePipelineCache"));
		vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(vkGetDeviceProcAddr(device, "vkDestroyPipelineCache"));
		vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(vkGetDeviceProcAddr(device, "vkGetPipelineCacheData"));
		vkMergePipelineCaches = PFN_vkMergePipelineCaches(vkGetDeviceProcAddr(device, "vkMergePipelineCaches"));
		vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(vkGetDeviceProcAddr(device, "vkCreateGraphicsPipelines"));
		vkCreateComputePipelines = PFN_vkCreateComputePipelines(vkGetDeviceProcAddr(device, "vkCreateComputePipelines"));
		vkDestroyPipeline = PFN_vkDestroyPipeline(vkGetDeviceProcAddr(device, "vkDestroyPipeline"));
		vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(vkGetDeviceProcAddr(device, "vkCreatePipelineLayout"));
		vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(vkGetDeviceProcAddr(device, "vkDestroyPipelineLayout"));
		vkCreateSampler = PFN_vkCreateSampler(vkGetDeviceProcAddr(device, "vkCreateSampler"));
		vkDestroySampler = PFN_vkDestroySampler(vkGetDeviceProcAddr(device, "vkDestroySampler"));
		vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkCreateDescriptorSetLayout"));
		vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout"));
		vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(vkGetDeviceProcAddr(device, "vkCreateDescriptorPool"));
		vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(vkGetDeviceProcAddr(device, "vkDestroyDescriptorPool"));
		vkResetDescriptorPool = PFN_vkResetDescriptorPool(vkGetDeviceProcAddr(device, "vkResetDescriptorPool"));
		vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(vkGetDeviceProcAddr(device, "vkAllocateDescriptorSets"));
		vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(vkGetDeviceProcAddr(device, "vkFreeDescriptorSets"));
		vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSets"));
		vkCreateFramebuffer = PFN_vkCreateFramebuffer(vkGetDeviceProcAddr(device, "vkCreateFramebuffer"));
		vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(vkGetDeviceProcAddr(device, "vkDestroyFramebuffer"));
		vkCreateRenderPass = PFN_vkCreateRenderPass(vkGetDeviceProcAddr(device, "vkCreateRenderPass"));
		vkDestroyRenderPass = PFN_vkDestroyRenderPass(vkGetDeviceProcAddr(device, "vkDestroyRenderPass"));
		vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(vkGetDeviceProcAddr(device, "vkGetRenderAreaGranularity"));
		vkCreateCommandPool = PFN_vkCreateCommandPool(vkGetDeviceProcAddr(device, "vkCreateCommandPool"));
		vkDestroyCommandPool = PFN_vkDestroyCommandPool(vkGetDeviceProcAddr(device, "vkDestroyCommandPool"));
		vkResetCommandPool = PFN_vkResetCommandPool(vkGetDeviceProcAddr(device, "vkResetCommandPool"));
		vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(vkGetDeviceProcAddr(device, "vkAllocateCommandBuffers"));
		vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(vkGetDeviceProcAddr(device, "vkFreeCommandBuffers"));
		vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(vkGetDeviceProcAddr(device, "vkBeginCommandBuffer"));
		vkEndCommandBuffer = PFN_vkEndCommandBuffer(vkGetDeviceProcAddr(device, "vkEndCommandBuffer"));
		vkResetCommandBuffer = PFN_vkResetCommandBuffer(vkGetDeviceProcAddr(device, "vkResetCommandBuffer"));
		vkCmdBindPipeline = PFN_vkCmdBindPipeline(vkGetDeviceProcAddr(device, "vkCmdBindPipeline"));
		vkCmdSetViewport = PFN_vkCmdSetViewport(vkGetDeviceProcAddr(device, "vkCmdSetViewport"));
		vkCmdSetScissor = PFN_vkCmdSetScissor(vkGetDeviceProcAddr(device, "vkCmdSetScissor"));
		vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(vkGetDeviceProcAddr(device, "vkCmdSetLineWidth"));
		vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(vkGetDeviceProcAddr(device, "vkCmdSetDepthBias"));
		vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(vkGetDeviceProcAddr(device, "vkCmdSetBlendConstants"));
		vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(vkGetDeviceProcAddr(device, "vkCmdSetDepthBounds"));
		vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilCompareMask"));
		vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilWriteMask"));
		vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(vkGetDeviceProcAddr(device, "vkCmdSetStencilReference"));
		vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(vkGetDeviceProcAddr(device, "vkCmdBindDescriptorSets"));
		vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(vkGetDeviceProcAddr(device, "vkCmdBindIndexBuffer"));
		vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers"));
		vkCmdDraw = PFN_vkCmdDraw(vkGetDeviceProcAddr(device, "vkCmdDraw"));
		vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(vkGetDeviceProcAddr(device, "vkCmdDrawIndexed"));
		vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndirect"));
		vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect"));
		vkCmdDispatch = PFN_vkCmdDispatch(vkGetDeviceProcAddr(device, "vkCmdDispatch"));
		vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(vkGetDeviceProcAddr(device, "vkCmdDispatchIndirect"));
		vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer"));
		vkCmdCopyImage = PFN_vkCmdCopyImage(vkGetDeviceProcAddr(device, "vkCmdCopyImage"));
		vkCmdBlitImage = PFN_vkCmdBlitImage(vkGetDeviceProcAddr(device, "vkCmdBlitImage"));
		vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage"));
		vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer"));
		vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(vkGetDeviceProcAddr(device, "vkCmdUpdateBuffer"));
		vkCmdFillBuffer = PFN_vkCmdFillBuffer(vkGetDeviceProcAddr(device, "vkCmdFillBuffer"));
		vkCmdClearColorImage = PFN_vkCmdClearColorImage(vkGetDeviceProcAddr(device, "vkCmdClearColorImage"));
		vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(vkGetDeviceProcAddr(device, "vkCmdClearDepthStencilImage"));
		vkCmdClearAttachments = PFN_vkCmdClearAttachments(vkGetDeviceProcAddr(device, "vkCmdClearAttachments"));
		vkCmdResolveImage = PFN_vkCmdResolveImage(vkGetDeviceProcAddr(device, "vkCmdResolveImage"));
		vkCmdSetEvent = PFN_vkCmdSetEvent(vkGetDeviceProcAddr(device, "vkCmdSetEvent"));
		vkCmdResetEvent = PFN_vkCmdResetEvent(vkGetDeviceProcAddr(device, "vkCmdResetEvent"));
		vkCmdWaitEvents = PFN_vkCmdWaitEvents(vkGetDeviceProcAddr(device, "vkCmdWaitEvents"));
		vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier"));
		vkCmdBeginQuery = PFN_vkCmdBeginQuery(vkGetDeviceProcAddr(device, "vkCmdBeginQuery"));
		vkCmdEndQuery = PFN_vkCmdEndQuery(vkGetDeviceProcAddr(device, "vkCmdEndQuery"));
		vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(vkGetDeviceProcAddr(device, "vkCmdResetQueryPool"));
		vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp"));
		vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(vkGetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults"));
		vkCmdPushConstants = PFN_vkCmdPushConstants(vkGetDeviceProcAddr(device, "vkCmdPushConstants"));
		vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass"));
		vkCmdNextSubpass = PFN_vkCmdNextSubpass(vkGetDeviceProcAddr(device, "vkCmdNextSubpass"));
		vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass"));
		vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(vkGetDeviceProcAddr(device, "vkCmdExecuteCommands"));

		//=== VK_VERSION_1_1 ===
		vkBindBufferMemory2 = PFN_vkBindBufferMemory2(vkGetDeviceProcAddr(device, "vkBindBufferMemory2"));
		vkBindImageMemory2 = PFN_vkBindImageMemory2(vkGetDeviceProcAddr(device, "vkBindImageMemory2"));
		vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures"));
		vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMask"));
		vkCmdDispatchBase = PFN_vkCmdDispatchBase(vkGetDeviceProcAddr(device, "vkCmdDispatchBase"));
		vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2"));
		vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2"));
		vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2"));
		vkTrimCommandPool = PFN_vkTrimCommandPool(vkGetDeviceProcAddr(device, "vkTrimCommandPool"));
		vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(vkGetDeviceProcAddr(device, "vkGetDeviceQueue2"));
		vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion"));
		vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion"));
		vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate"));
		vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate"));
		vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate"));
		vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport"));

		//=== VK_VERSION_1_2 ===
		vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCount"));
		vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount"));
		vkCreateRenderPass2 = PFN_vkCreateRenderPass2(vkGetDeviceProcAddr(device, "vkCreateRenderPass2"));
		vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2"));
		vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2"));
		vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2"));
		vkResetQueryPool = PFN_vkResetQueryPool(vkGetDeviceProcAddr(device, "vkResetQueryPool"));
		vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValue"));
		vkWaitSemaphores = PFN_vkWaitSemaphores(vkGetDeviceProcAddr(device, "vkWaitSemaphores"));
		vkSignalSemaphore = PFN_vkSignalSemaphore(vkGetDeviceProcAddr(device, "vkSignalSemaphore"));
		vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddress"));
		vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress"));
		vkGetDeviceMemoryOpaqueCaptureAddress =
		    PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress"));

		//=== VK_VERSION_1_3 ===
		vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlot"));
		vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlot"));
		vkSetPrivateData = PFN_vkSetPrivateData(vkGetDeviceProcAddr(device, "vkSetPrivateData"));
		vkGetPrivateData = PFN_vkGetPrivateData(vkGetDeviceProcAddr(device, "vkGetPrivateData"));
		vkCmdSetEvent2 = PFN_vkCmdSetEvent2(vkGetDeviceProcAddr(device, "vkCmdSetEvent2"));
		vkCmdResetEvent2 = PFN_vkCmdResetEvent2(vkGetDeviceProcAddr(device, "vkCmdResetEvent2"));
		vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2"));
		vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2"));
		vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2"));
		vkQueueSubmit2 = PFN_vkQueueSubmit2(vkGetDeviceProcAddr(device, "vkQueueSubmit2"));
		vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2"));
		vkCmdCopyImage2 = PFN_vkCmdCopyImage2(vkGetDeviceProcAddr(device, "vkCmdCopyImage2"));
		vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2"));
		vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2"));
		vkCmdBlitImage2 = PFN_vkCmdBlitImage2(vkGetDeviceProcAddr(device, "vkCmdBlitImage2"));
		vkCmdResolveImage2 = PFN_vkCmdResolveImage2(vkGetDeviceProcAddr(device, "vkCmdResolveImage2"));
		vkCmdBeginRendering = PFN_vkCmdBeginRendering(vkGetDeviceProcAddr(device, "vkCmdBeginRendering"));
		vkCmdEndRendering = PFN_vkCmdEndRendering(vkGetDeviceProcAddr(device, "vkCmdEndRendering"));
		vkCmdSetCullMode = PFN_vkCmdSetCullMode(vkGetDeviceProcAddr(device, "vkCmdSetCullMode"));
		vkCmdSetFrontFace = PFN_vkCmdSetFrontFace(vkGetDeviceProcAddr(device, "vkCmdSetFrontFace"));
		vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology"));
		vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCount"));
		vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCount"));
		vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2"));
		vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnable"));
		vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable"));
		vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOp"));
		vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable"));
		vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnable"));
		vkCmdSetStencilOp = PFN_vkCmdSetStencilOp(vkGetDeviceProcAddr(device, "vkCmdSetStencilOp"));
		vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable"));
		vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable"));
		vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable"));
		vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements"));
		vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements"));
		vkGetDeviceImageSparseMemoryRequirements =
		    PFN_vkGetDeviceImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements"));

		//=== VK_KHR_swapchain ===
		vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(vkGetDeviceProcAddr(device, "vkCreateSwapchainKHR"));
		vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(vkGetDeviceProcAddr(device, "vkDestroySwapchainKHR"));
		vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainImagesKHR"));
		vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(vkGetDeviceProcAddr(device, "vkAcquireNextImageKHR"));
		vkQueuePresentKHR = PFN_vkQueuePresentKHR(vkGetDeviceProcAddr(device, "vkQueuePresentKHR"));
		vkGetDeviceGroupPresentCapabilitiesKHR =
		    PFN_vkGetDeviceGroupPresentCapabilitiesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR"));
		vkGetDeviceGroupSurfacePresentModesKHR =
		    PFN_vkGetDeviceGroupSurfacePresentModesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR"));
		vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(vkGetDeviceProcAddr(device, "vkAcquireNextImage2KHR"));

		//=== VK_KHR_display_swapchain ===
		vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(vkGetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR"));

		//=== VK_EXT_debug_marker ===
		vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT"));
		vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT"));
		vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT"));
		vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT"));
		vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT"));

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_queue ===
		vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionKHR"));
		vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionKHR"));
		vkGetVideoSessionMemoryRequirementsKHR =
		    PFN_vkGetVideoSessionMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR"));
		vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR(vkGetDeviceProcAddr(device, "vkBindVideoSessionMemoryKHR"));
		vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionParametersKHR"));
		vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkUpdateVideoSessionParametersKHR"));
		vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionParametersKHR"));
		vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginVideoCodingKHR"));
		vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdEndVideoCodingKHR"));
		vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_decode_queue ===
		vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdDecodeVideoKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

		//=== VK_EXT_transform_feedback ===
		vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(vkGetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT"));
		vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT"));
		vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT"));
		vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT"));
		vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT"));
		vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT"));

		//=== VK_NVX_binary_import ===
		vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX(vkGetDeviceProcAddr(device, "vkCreateCuModuleNVX"));
		vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX(vkGetDeviceProcAddr(device, "vkCreateCuFunctionNVX"));
		vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX(vkGetDeviceProcAddr(device, "vkDestroyCuModuleNVX"));
		vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX(vkGetDeviceProcAddr(device, "vkDestroyCuFunctionNVX"));
		vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX(vkGetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX"));

		//=== VK_NVX_image_view_handle ===
		vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX(vkGetDeviceProcAddr(device, "vkGetImageViewHandleNVX"));
		vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX(vkGetDeviceProcAddr(device, "vkGetImageViewAddressNVX"));

		//=== VK_AMD_draw_indirect_count ===
		vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD"));
		if(!vkCmdDrawIndirectCount)
			vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
		vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD"));
		if(!vkCmdDrawIndexedIndirectCount)
			vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;

		//=== VK_AMD_shader_info ===
		vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(vkGetDeviceProcAddr(device, "vkGetShaderInfoAMD"));

		//=== VK_KHR_dynamic_rendering ===
		vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderingKHR"));
		if(!vkCmdBeginRendering)
			vkCmdBeginRendering = vkCmdBeginRenderingKHR;
		vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderingKHR"));
		if(!vkCmdEndRendering)
			vkCmdEndRendering = vkCmdEndRenderingKHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_NV_external_memory_win32 ===
		vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_device_group ===
		vkGetDeviceGroupPeerMemoryFeaturesKHR =
		    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR"));
		if(!vkGetDeviceGroupPeerMemoryFeatures)
			vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
		vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR"));
		if(!vkCmdSetDeviceMask)
			vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
		vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(vkGetDeviceProcAddr(device, "vkCmdDispatchBaseKHR"));
		if(!vkCmdDispatchBase)
			vkCmdDispatchBase = vkCmdDispatchBaseKHR;

		//=== VK_KHR_maintenance1 ===
		vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(vkGetDeviceProcAddr(device, "vkTrimCommandPoolKHR"));
		if(!vkTrimCommandPool)
			vkTrimCommandPool = vkTrimCommandPoolKHR;

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_memory_win32 ===
		vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR"));
		vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_memory_fd ===
		vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdKHR"));
		vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR"));

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_semaphore_win32 ===
		vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR"));
		vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_semaphore_fd ===
		vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreFdKHR"));
		vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreFdKHR"));

		//=== VK_KHR_push_descriptor ===
		vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR"));
		vkCmdPushDescriptorSetWithTemplateKHR =
		    PFN_vkCmdPushDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR"));

		//=== VK_EXT_conditional_rendering ===
		vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT"));
		vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT"));

		//=== VK_KHR_descriptor_update_template ===
		vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR"));
		if(!vkCreateDescriptorUpdateTemplate)
			vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
		vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR"));
		if(!vkDestroyDescriptorUpdateTemplate)
			vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
		vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR"));
		if(!vkUpdateDescriptorSetWithTemplate)
			vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;

		//=== VK_NV_clip_space_w_scaling ===
		vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV"));

		//=== VK_EXT_display_control ===
		vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(vkGetDeviceProcAddr(device, "vkDisplayPowerControlEXT"));
		vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDeviceEventEXT"));
		vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDisplayEventEXT"));
		vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(vkGetDeviceProcAddr(device, "vkGetSwapchainCounterEXT"));

		//=== VK_GOOGLE_display_timing ===
		vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(vkGetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE"));
		vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(vkGetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE"));

		//=== VK_EXT_discard_rectangles ===
		vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(vkGetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT"));

		//=== VK_EXT_hdr_metadata ===
		vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(vkGetDeviceProcAddr(device, "vkSetHdrMetadataEXT"));

		//=== VK_KHR_create_renderpass2 ===
		vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR"));
		if(!vkCreateRenderPass2)
			vkCreateRenderPass2 = vkCreateRenderPass2KHR;
		vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR"));
		if(!vkCmdBeginRenderPass2)
			vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
		vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2KHR"));
		if(!vkCmdNextSubpass2)
			vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
		vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR"));
		if(!vkCmdEndRenderPass2)
			vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;

		//=== VK_KHR_shared_presentable_image ===
		vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainStatusKHR"));

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_KHR_external_fence_win32 ===
		vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR"));
		vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_external_fence_fd ===
		vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(vkGetDeviceProcAddr(device, "vkImportFenceFdKHR"));
		vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(vkGetDeviceProcAddr(device, "vkGetFenceFdKHR"));

		//=== VK_KHR_performance_query ===
		vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR(vkGetDeviceProcAddr(device, "vkAcquireProfilingLockKHR"));
		vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR(vkGetDeviceProcAddr(device, "vkReleaseProfilingLockKHR"));

		//=== VK_EXT_debug_utils ===
		vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT"));
		vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT"));
		vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT"));
		vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT"));
		vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT"));
		vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT"));
		vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT"));
		vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT"));

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
		//=== VK_ANDROID_external_memory_android_hardware_buffer ===
		vkGetAndroidHardwareBufferPropertiesANDROID =
		    PFN_vkGetAndroidHardwareBufferPropertiesANDROID(vkGetDeviceProcAddr(device, "vkGetAndroidHardwareBufferPropertiesANDROID"));
		vkGetMemoryAndroidHardwareBufferANDROID =
		    PFN_vkGetMemoryAndroidHardwareBufferANDROID(vkGetDeviceProcAddr(device, "vkGetMemoryAndroidHardwareBufferANDROID"));
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/

		//=== VK_EXT_sample_locations ===
		vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(vkGetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT"));

		//=== VK_KHR_get_memory_requirements2 ===
		vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR"));
		if(!vkGetImageMemoryRequirements2)
			vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
		vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR"));
		if(!vkGetBufferMemoryRequirements2)
			vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
		vkGetImageSparseMemoryRequirements2KHR =
		    PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR"));
		if(!vkGetImageSparseMemoryRequirements2)
			vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;

		//=== VK_KHR_acceleration_structure ===
		vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR"));
		vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR"));
		vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR"));
		vkCmdBuildAccelerationStructuresIndirectKHR =
		    PFN_vkCmdBuildAccelerationStructuresIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR"));
		vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR"));
		vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR"));
		vkCopyAccelerationStructureToMemoryKHR =
		    PFN_vkCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR"));
		vkCopyMemoryToAccelerationStructureKHR =
		    PFN_vkCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR"));
		vkWriteAccelerationStructuresPropertiesKHR =
		    PFN_vkWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR"));
		vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR"));
		vkCmdCopyAccelerationStructureToMemoryKHR =
		    PFN_vkCmdCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR"));
		vkCmdCopyMemoryToAccelerationStructureKHR =
		    PFN_vkCmdCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR"));
		vkGetAccelerationStructureDeviceAddressKHR =
		    PFN_vkGetAccelerationStructureDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR"));
		vkCmdWriteAccelerationStructuresPropertiesKHR =
		    PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR"));
		vkGetDeviceAccelerationStructureCompatibilityKHR =
		    PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(vkGetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR"));
		vkGetAccelerationStructureBuildSizesKHR =
		    PFN_vkGetAccelerationStructureBuildSizesKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR"));

		//=== VK_KHR_sampler_ycbcr_conversion ===
		vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR"));
		if(!vkCreateSamplerYcbcrConversion)
			vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
		vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR"));
		if(!vkDestroySamplerYcbcrConversion)
			vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;

		//=== VK_KHR_bind_memory2 ===
		vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(vkGetDeviceProcAddr(device, "vkBindBufferMemory2KHR"));
		if(!vkBindBufferMemory2)
			vkBindBufferMemory2 = vkBindBufferMemory2KHR;
		vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(vkGetDeviceProcAddr(device, "vkBindImageMemory2KHR"));
		if(!vkBindImageMemory2)
			vkBindImageMemory2 = vkBindImageMemory2KHR;

		//=== VK_EXT_image_drm_format_modifier ===
		vkGetImageDrmFormatModifierPropertiesEXT =
		    PFN_vkGetImageDrmFormatModifierPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT"));

		//=== VK_EXT_validation_cache ===
		vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(vkGetDeviceProcAddr(device, "vkCreateValidationCacheEXT"));
		vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(vkGetDeviceProcAddr(device, "vkDestroyValidationCacheEXT"));
		vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(vkGetDeviceProcAddr(device, "vkMergeValidationCachesEXT"));
		vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(vkGetDeviceProcAddr(device, "vkGetValidationCacheDataEXT"));

		//=== VK_NV_shading_rate_image ===
		vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(vkGetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV"));
		vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV"));
		vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(vkGetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV"));

		//=== VK_NV_ray_tracing ===
		vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureNV"));
		vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV"));
		vkGetAccelerationStructureMemoryRequirementsNV =
		    PFN_vkGetAccelerationStructureMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV"));
		vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(vkGetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV"));
		vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV"));
		vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV"));
		vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(vkGetDeviceProcAddr(device, "vkCmdTraceRaysNV"));
		vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV"));
		vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV"));
		if(!vkGetRayTracingShaderGroupHandlesKHR)
			vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
		vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV"));
		vkCmdWriteAccelerationStructuresPropertiesNV =
		    PFN_vkCmdWriteAccelerationStructuresPropertiesNV(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV"));
		vkCompileDeferredNV = PFN_vkCompileDeferredNV(vkGetDeviceProcAddr(device, "vkCompileDeferredNV"));

		//=== VK_KHR_maintenance3 ===
		vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR"));
		if(!vkGetDescriptorSetLayoutSupport)
			vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;

		//=== VK_KHR_draw_indirect_count ===
		vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR"));
		if(!vkCmdDrawIndirectCount)
			vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
		vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR"));
		if(!vkCmdDrawIndexedIndirectCount)
			vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;

		//=== VK_EXT_external_memory_host ===
		vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT"));

		//=== VK_AMD_buffer_marker ===
		vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD"));

		//=== VK_EXT_calibrated_timestamps ===
		vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(vkGetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT"));

		//=== VK_NV_mesh_shader ===
		vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV"));
		vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV"));
		vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV"));

		//=== VK_NV_scissor_exclusive ===
		vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(vkGetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV"));

		//=== VK_NV_device_diagnostic_checkpoints ===
		vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(vkGetDeviceProcAddr(device, "vkCmdSetCheckpointNV"));
		vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV"));

		//=== VK_KHR_timeline_semaphore ===
		vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR"));
		if(!vkGetSemaphoreCounterValue)
			vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
		vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(vkGetDeviceProcAddr(device, "vkWaitSemaphoresKHR"));
		if(!vkWaitSemaphores)
			vkWaitSemaphores = vkWaitSemaphoresKHR;
		vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(vkGetDeviceProcAddr(device, "vkSignalSemaphoreKHR"));
		if(!vkSignalSemaphore)
			vkSignalSemaphore = vkSignalSemaphoreKHR;

		//=== VK_INTEL_performance_query ===
		vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL"));
		vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL"));
		vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL"));
		vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL"));
		vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL"));
		vkAcquirePerformanceConfigurationINTEL =
		    PFN_vkAcquirePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL"));
		vkReleasePerformanceConfigurationINTEL =
		    PFN_vkReleasePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL"));
		vkQueueSetPerformanceConfigurationINTEL =
		    PFN_vkQueueSetPerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL"));
		vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL(vkGetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL"));

		//=== VK_AMD_display_native_hdr ===
		vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD(vkGetDeviceProcAddr(device, "vkSetLocalDimmingAMD"));

		//=== VK_KHR_fragment_shading_rate ===
		vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR"));

		//=== VK_EXT_buffer_device_address ===
		vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT"));
		if(!vkGetBufferDeviceAddress)
			vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;

		//=== VK_KHR_present_wait ===
		vkWaitForPresentKHR = PFN_vkWaitForPresentKHR(vkGetDeviceProcAddr(device, "vkWaitForPresentKHR"));

#if defined(VK_USE_PLATFORM_WIN32_KHR)
		//=== VK_EXT_full_screen_exclusive ===
		vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT"));
		vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT"));
		vkGetDeviceGroupSurfacePresentModes2EXT =
		    PFN_vkGetDeviceGroupSurfacePresentModes2EXT(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT"));
#endif /*VK_USE_PLATFORM_WIN32_KHR*/

		//=== VK_KHR_buffer_device_address ===
		vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR"));
		if(!vkGetBufferDeviceAddress)
			vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
		vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR"));
		if(!vkGetBufferOpaqueCaptureAddress)
			vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
		vkGetDeviceMemoryOpaqueCaptureAddressKHR =
		    PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"));
		if(!vkGetDeviceMemoryOpaqueCaptureAddress)
			vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;

		//=== VK_EXT_line_rasterization ===
		vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT(vkGetDeviceProcAddr(device, "vkCmdSetLineStippleEXT"));

		//=== VK_EXT_host_query_reset ===
		vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(vkGetDeviceProcAddr(device, "vkResetQueryPoolEXT"));
		if(!vkResetQueryPool)
			vkResetQueryPool = vkResetQueryPoolEXT;

		//=== VK_EXT_extended_dynamic_state ===
		vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT(vkGetDeviceProcAddr(device, "vkCmdSetCullModeEXT"));
		if(!vkCmdSetCullMode)
			vkCmdSetCullMode = vkCmdSetCullModeEXT;
		vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT(vkGetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT"));
		if(!vkCmdSetFrontFace)
			vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
		vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT"));
		if(!vkCmdSetPrimitiveTopology)
			vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
		vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT"));
		if(!vkCmdSetViewportWithCount)
			vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
		vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT"));
		if(!vkCmdSetScissorWithCount)
			vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
		vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT"));
		if(!vkCmdBindVertexBuffers2)
			vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
		vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT"));
		if(!vkCmdSetDepthTestEnable)
			vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
		vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT"));
		if(!vkCmdSetDepthWriteEnable)
			vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
		vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT"));
		if(!vkCmdSetDepthCompareOp)
			vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
		vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT"));
		if(!vkCmdSetDepthBoundsTestEnable)
			vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
		vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT"));
		if(!vkCmdSetStencilTestEnable)
			vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
		vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilOpEXT"));
		if(!vkCmdSetStencilOp)
			vkCmdSetStencilOp = vkCmdSetStencilOpEXT;

		//=== VK_KHR_deferred_host_operations ===
		vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkCreateDeferredOperationKHR"));
		vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR"));
		vkGetDeferredOperationMaxConcurrencyKHR =
		    PFN_vkGetDeferredOperationMaxConcurrencyKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR"));
		vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR"));
		vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR(vkGetDeviceProcAddr(device, "vkDeferredOperationJoinKHR"));

		//=== VK_KHR_pipeline_executable_properties ===
		vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR"));
		vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR"));
		vkGetPipelineExecutableInternalRepresentationsKHR =
		    PFN_vkGetPipelineExecutableInternalRepresentationsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR"));

		//=== VK_NV_device_generated_commands ===
		vkGetGeneratedCommandsMemoryRequirementsNV =
		    PFN_vkGetGeneratedCommandsMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV"));
		vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV"));
		vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV"));
		vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV(vkGetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV"));
		vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV"));
		vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV"));

		//=== VK_EXT_private_data ===
		vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT"));
		if(!vkCreatePrivateDataSlot)
			vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
		vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT"));
		if(!vkDestroyPrivateDataSlot)
			vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
		vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkSetPrivateDataEXT"));
		if(!vkSetPrivateData)
			vkSetPrivateData = vkSetPrivateDataEXT;
		vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkGetPrivateDataEXT"));
		if(!vkGetPrivateData)
			vkGetPrivateData = vkGetPrivateDataEXT;

#if defined(VK_ENABLE_BETA_EXTENSIONS)
		//=== VK_KHR_video_encode_queue ===
		vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdEncodeVideoKHR"));
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

		//=== VK_KHR_synchronization2 ===
		vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdSetEvent2KHR"));
		if(!vkCmdSetEvent2)
			vkCmdSetEvent2 = vkCmdSetEvent2KHR;
		vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdResetEvent2KHR"));
		if(!vkCmdResetEvent2)
			vkCmdResetEvent2 = vkCmdResetEvent2KHR;
		vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2KHR"));
		if(!vkCmdWaitEvents2)
			vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
		vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR"));
		if(!vkCmdPipelineBarrier2)
			vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
		vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR"));
		if(!vkCmdWriteTimestamp2)
			vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
		vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR(vkGetDeviceProcAddr(device, "vkQueueSubmit2KHR"));
		if(!vkQueueSubmit2)
			vkQueueSubmit2 = vkQueueSubmit2KHR;
		vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD"));
		vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV"));

		//=== VK_NV_fragment_shading_rate_enums ===
		vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV"));

		//=== VK_KHR_copy_commands2 ===
		vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR"));
		if(!vkCmdCopyBuffer2)
			vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
		vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImage2KHR"));
		if(!vkCmdCopyImage2)
			vkCmdCopyImage2 = vkCmdCopyImage2KHR;
		vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR"));
		if(!vkCmdCopyBufferToImage2)
			vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
		vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR"));
		if(!vkCmdCopyImageToBuffer2)
			vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
		vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR(vkGetDeviceProcAddr(device, "vkCmdBlitImage2KHR"));
		if(!vkCmdBlitImage2)
			vkCmdBlitImage2 = vkCmdBlitImage2KHR;
		vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR(vkGetDeviceProcAddr(device, "vkCmdResolveImage2KHR"));
		if(!vkCmdResolveImage2)
			vkCmdResolveImage2 = vkCmdResolveImage2KHR;

		//=== VK_KHR_ray_tracing_pipeline ===
		vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysKHR"));
		vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR"));
		vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR"));
		vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
		    PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"));
		vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR"));
		vkGetRayTracingShaderGroupStackSizeKHR =
		    PFN_vkGetRayTracingShaderGroupStackSizeKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR"));
		vkCmdSetRayTracingPipelineStackSizeKHR =
		    PFN_vkCmdSetRayTracingPipelineStackSizeKHR(vkGetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR"));

		//=== VK_EXT_vertex_input_dynamic_state ===
		vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT(vkGetDeviceProcAddr(device, "vkCmdSetVertexInputEXT"));

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_external_memory ===
		vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandleFUCHSIA"));
		vkGetMemoryZirconHandlePropertiesFUCHSIA =
		    PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_external_semaphore ===
		vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkImportSemaphoreZirconHandleFUCHSIA"));
		vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetSemaphoreZirconHandleFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if defined(VK_USE_PLATFORM_FUCHSIA)
		//=== VK_FUCHSIA_buffer_collection ===
		vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkCreateBufferCollectionFUCHSIA"));
		vkSetBufferCollectionImageConstraintsFUCHSIA =
		    PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionImageConstraintsFUCHSIA"));
		vkSetBufferCollectionBufferConstraintsFUCHSIA =
		    PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA"));
		vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkDestroyBufferCollectionFUCHSIA"));
		vkGetBufferCollectionPropertiesFUCHSIA =
		    PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetBufferCollectionPropertiesFUCHSIA"));
#endif /*VK_USE_PLATFORM_FUCHSIA*/

		//=== VK_HUAWEI_subpass_shading ===
		vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
		    PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(vkGetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"));
		vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI(vkGetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI"));

		//=== VK_HUAWEI_invocation_mask ===
		vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI(vkGetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI"));

		//=== VK_NV_external_memory_rdma ===
		vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV(vkGetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV"));

		//=== VK_EXT_extended_dynamic_state2 ===
		vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT(vkGetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT"));
		vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT"));
		if(!vkCmdSetRasterizerDiscardEnable)
			vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
		vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT"));
		if(!vkCmdSetDepthBiasEnable)
			vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
		vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetLogicOpEXT"));
		vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT"));
		if(!vkCmdSetPrimitiveRestartEnable)
			vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;

		//=== VK_EXT_color_write_enable ===
		vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetColorWriteEnableEXT"));

		//=== VK_EXT_multi_draw ===
		vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiEXT"));
		vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT"));

		//=== VK_EXT_pageable_device_local_memory ===
		vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT(vkGetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT"));

		//=== VK_KHR_maintenance4 ===
		vkGetDeviceBufferMemoryRequirementsKHR =
		    PFN_vkGetDeviceBufferMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR"));
		if(!vkGetDeviceBufferMemoryRequirements)
			vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
		vkGetDeviceImageMemoryRequirementsKHR =
		    PFN_vkGetDeviceImageMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR"));
		if(!vkGetDeviceImageMemoryRequirements)
			vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
		vkGetDeviceImageSparseMemoryRequirementsKHR =
		    PFN_vkGetDeviceImageSparseMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR"));
		if(!vkGetDeviceImageSparseMemoryRequirements)
			vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;

		//=== VK_VALVE_descriptor_set_host_mapping ===
		vkGetDescriptorSetLayoutHostMappingInfoVALVE =
		    PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE"));
		vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE"));
	}
};
}  // namespace VULKAN_HPP_NAMESPACE
#endif